atomism 0.1.0

package/dist/import-generator-4CKRBMTE.js

@@ -0,0 +1,1864 @@
+import {
+  toErrorMessage
+} from "./chunk-PLQJM2KT.js";
+
+// src/importer/plop.ts
+import { join, basename } from "path";
+import { readFile, writeFile, mkdir, access } from "fs/promises";
+var PROMPT_TYPE_MAP = {
+  input: "z.string()",
+  number: "z.number()",
+  confirm: "z.boolean()",
+  list: "z.string()",
+  // Will be enum if choices exist
+  rawlist: "z.string()",
+  expand: "z.string()",
+  checkbox: "z.array(z.string())",
+  password: "z.string()",
+  editor: "z.string()"
+};
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractGenerators(content) {
+  const generators = /* @__PURE__ */ new Map();
+  const regex = /setGenerator\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\{[\s\S]*?\})\s*\)/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const name = match[1];
+    const config = match[2];
+    if (name && config) {
+      generators.set(name, config);
+    }
+  }
+  return generators;
+}
+function escapeStringLiteral(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function areBracesBalanced(str) {
+  let count = 0;
+  for (const char of str) {
+    if (char === "{") count++;
+    if (char === "}") count--;
+    if (count < 0) return false;
+  }
+  return count === 0;
+}
+function parsePrompts(config) {
+  const prompts = [];
+  const promptsMatch = config.match(/prompts\s*:\s*\[([\s\S]*?)\]/);
+  if (!promptsMatch) {
+    return prompts;
+  }
+  const promptsStr = promptsMatch[1];
+  if (!promptsStr) return prompts;
+  const promptParts = promptsStr.split(/\{\s*type\s*:/);
+  for (const part of promptParts) {
+    if (!part.trim()) continue;
+    const promptStr = "{ type:" + part;
+    const typeMatch = promptStr.match(/type\s*:\s*['"]([^'"]+)['"]/);
+    const type = typeMatch?.[1];
+    if (!type) continue;
+    const nameMatch = promptStr.match(/name\s*:\s*['"]([^'"]+)['"]/);
+    const name = nameMatch?.[1];
+    if (!name) continue;
+    const messageMatch = promptStr.match(/message\s*:\s*['"]([^'"]+)['"]/);
+    const message = messageMatch?.[1];
+    const defaultMatch = promptStr.match(/default\s*:\s*['"]?([^'",}]+)['"]?/);
+    const defaultVal = defaultMatch?.[1];
+    prompts.push({
+      type,
+      name,
+      message,
+      default: defaultVal
+    });
+  }
+  return prompts;
+}
+function parseActions(config) {
+  const actions = [];
+  const actionsMatch = config.match(/actions\s*:\s*\[([\s\S]*?)\]/);
+  if (!actionsMatch) {
+    return actions;
+  }
+  const actionsStr = actionsMatch[1];
+  if (!actionsStr) return actions;
+  const actionParts = actionsStr.split(/\{\s*type\s*:/);
+  for (const part of actionParts) {
+    if (!part.trim()) continue;
+    const actionStr = "{ type:" + part;
+    const typeMatch = actionStr.match(/type\s*:\s*['"]([^'"]+)['"]/);
+    const type = typeMatch?.[1];
+    if (!type) continue;
+    const pathMatch = actionStr.match(/path\s*:\s*['"`]([^'"`]*(?:\{\{[^}]+\}\}[^'"`]*)*)['"`]/);
+    const path = pathMatch?.[1];
+    const templateFileMatch = actionStr.match(/templateFile\s*:\s*['"`]([^'"`]+)['"`]/);
+    const templateFile = templateFileMatch?.[1];
+    const templateMatch = actionStr.match(/template\s*:\s*['"`]([^'"`]+)['"`]/);
+    const template = templateMatch?.[1];
+    actions.push({
+      type,
+      path,
+      templateFile,
+      template
+    });
+  }
+  return actions;
+}
+function promptsToZod(prompts) {
+  if (prompts.length === 0) {
+    return "z.object({})";
+  }
+  const fields = prompts.map((prompt) => {
+    let zodType = PROMPT_TYPE_MAP[prompt.type] || "z.string()";
+    if (prompt.message) {
+      zodType += `.describe('${escapeStringLiteral(prompt.message)}')`;
+    }
+    if (prompt.default !== void 0) {
+      if (typeof prompt.default === "string") {
+        zodType += `.default('${escapeStringLiteral(prompt.default)}')`;
+      } else if (typeof prompt.default === "number") {
+        zodType += `.default(${prompt.default})`;
+      } else if (typeof prompt.default === "boolean") {
+        zodType += `.default(${prompt.default})`;
+      }
+    }
+    return `  ${prompt.name}: ${zodType}`;
+  });
+  return `z.object({
+${fields.join(",\n")}
+})`;
+}
+function actionsToTemplate(actions, prompts) {
+  const paramNames = prompts.map((p) => p.name);
+  const destructure = paramNames.length > 0 ? `{ ${paramNames.join(", ")} }` : "_params";
+  const outputs = [];
+  for (const action of actions) {
+    if (action.type === "add" && action.path) {
+      const path = action.path.replace(/\{\{([^}]+)\}\}/g, "${$1}");
+      outputs.push(`  // Output: ${path}`);
+      if (action.templateFile) {
+        outputs.push(`  // Template: ${action.templateFile}`);
+      } else if (action.template) {
+        outputs.push(`  // Inline template`);
+      }
+    } else if (action.type === "modify" && action.path) {
+      const path = action.path.replace(/\{\{([^}]+)\}\}/g, "${$1}");
+      outputs.push(`  // Modify: ${path}`);
+    } else if (action.type === "append" && action.path) {
+      const path = action.path.replace(/\{\{([^}]+)\}\}/g, "${$1}");
+      outputs.push(`  // Append to: ${path}`);
+    }
+  }
+  if (outputs.length === 0) {
+    outputs.push("  // No actions to convert");
+  }
+  return `(${destructure}) => {
+${outputs.join("\n")}
+  return \`
+// TODO: Implement template based on Plop actions
+// Original actions: ${actions.length}
+\`;
+}`;
+}
+function generateAtomicGenerator(parsed) {
+  const zodSchema = promptsToZod(parsed.prompts);
+  const templateFn = actionsToTemplate(parsed.actions, parsed.prompts);
+  return `/**
+ * Atomic generator: ${parsed.name}
+ *
+ * Imported from Plop generator.
+ * ${parsed.description ? `Description: ${parsed.description}` : ""}
+ *
+ * @module generators/${parsed.name}
+ */
+
+import { z } from 'atomism';
+
+/**
+ * Generator parameters schema.
+ *
+ * Converted from Plop prompts:
+${parsed.prompts.map((p) => ` * - ${p.name}: ${p.type}${p.message ? ` (${p.message})` : ""}`).join("\n")}
+ */
+export const paramsSchema = ${zodSchema};
+
+export type Params = z.infer<typeof paramsSchema>;
+
+/**
+ * Template function.
+ *
+ * Converted from Plop actions:
+${parsed.actions.map((a) => ` * - ${a.type}: ${a.path || a.templateFile || "inline"}`).join("\n")}
+ */
+export const template = ${templateFn};
+
+/**
+ * Generator metadata.
+ */
+export const generator = {
+  name: '${escapeStringLiteral(parsed.name)}',
+  description: '${escapeStringLiteral(parsed.description || `Generator for ${parsed.name}`)}',
+  params: paramsSchema,
+  template,
+  language: 'typescript' as const,
+};
+
+export default generator;
+`;
+}
+async function importPlopGenerator(options) {
+  const {
+    projectRoot,
+    generatorName,
+    outputDir = "generators",
+    overwrite = false
+  } = options;
+  const result = {
+    success: false,
+    mappings: [],
+    warnings: [],
+    errors: []
+  };
+  const plopFiles = ["plopfile.js", "plopfile.ts", "plopfile.mjs", "plopfile.cjs"];
+  let plopPath = null;
+  for (const file of plopFiles) {
+    const path = join(projectRoot, file);
+    if (await pathExists(path)) {
+      plopPath = path;
+      break;
+    }
+  }
+  if (!plopPath) {
+    result.errors.push("No plopfile found in project root");
+    return result;
+  }
+  let content;
+  try {
+    content = await readFile(plopPath, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to read plopfile: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const generators = extractGenerators(content);
+  if (!generators.has(generatorName)) {
+    result.errors.push(
+      `Generator '${generatorName}' not found. Available: ${Array.from(generators.keys()).join(", ") || "none"}`
+    );
+    return result;
+  }
+  const generatorConfig = generators.get(generatorName);
+  if (!areBracesBalanced(generatorConfig)) {
+    result.warnings.push(
+      `Generator '${generatorName}' config may be malformed (unbalanced braces). Parsing may be incomplete.`
+    );
+  }
+  const prompts = parsePrompts(generatorConfig);
+  const actions = parseActions(generatorConfig);
+  for (const prompt of prompts) {
+    result.mappings.push({
+      source: `prompt:${prompt.name}`,
+      target: `params.${prompt.name}`,
+      type: "prompt",
+      notes: `${prompt.type} \u2192 ${PROMPT_TYPE_MAP[prompt.type] || "z.string()"}`
+    });
+  }
+  for (const action of actions) {
+    result.mappings.push({
+      source: `action:${action.type}`,
+      target: action.path || action.templateFile || "inline",
+      type: "action",
+      notes: action.templateFile ? `templateFile: ${action.templateFile}` : void 0
+    });
+  }
+  const templateFiles = actions.filter((a) => a.templateFile).map((a) => a.templateFile);
+  const parsed = {
+    name: generatorName,
+    prompts,
+    actions,
+    templateFiles
+  };
+  const descMatch = generatorConfig.match(/description\s*:\s*['"]([^'"]+)['"]/);
+  if (descMatch) {
+    parsed.description = descMatch[1];
+  }
+  const atomicGenerator = generateAtomicGenerator(parsed);
+  const safeGeneratorName = basename(generatorName);
+  if (safeGeneratorName !== generatorName || generatorName.includes("..")) {
+    result.errors.push(
+      `Invalid generator name '${generatorName}': must be a simple filename without path components`
+    );
+    return result;
+  }
+  const outputPath = join(projectRoot, outputDir);
+  try {
+    await mkdir(outputPath, { recursive: true });
+  } catch (err) {
+    result.errors.push(`Failed to create output directory: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const generatorPath = join(outputPath, `${safeGeneratorName}.ts`);
+  if (await pathExists(generatorPath) && !overwrite) {
+    result.errors.push(
+      `Generator file already exists: ${generatorPath}. Use --overwrite to replace.`
+    );
+    return result;
+  }
+  try {
+    await writeFile(generatorPath, atomicGenerator, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to write generator: ${toErrorMessage(err)}`);
+    return result;
+  }
+  if (prompts.length === 0) {
+    result.warnings.push("No prompts found - generator will have empty params");
+  }
+  if (actions.length === 0) {
+    result.warnings.push("No actions found - template function is placeholder");
+  }
+  for (const action of actions) {
+    if (action.templateFile) {
+      result.warnings.push(
+        `Template file '${action.templateFile}' needs manual conversion`
+      );
+    }
+  }
+  result.success = true;
+  result.generatorPath = generatorPath;
+  return result;
+}
+
+// src/importer/hygen.ts
+import { join as join2, basename as basename2 } from "path";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access as access2, readdir } from "fs/promises";
+var PROMPT_TYPE_MAP2 = {
+  input: "z.string()",
+  text: "z.string()",
+  number: "z.number()",
+  confirm: "z.boolean()",
+  toggle: "z.boolean()",
+  select: "z.string()",
+  multiselect: "z.array(z.string())",
+  list: "z.string()",
+  autocomplete: "z.string()"
+};
+async function pathExists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function escapeStringLiteral2(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function sanitizeJsDocContent(str) {
+  return str.replace(/\*\//g, "*\\/").replace(/\/\*/g, "/\\*");
+}
+function parseFrontmatter(content) {
+  const frontmatter = {};
+  const normalizedContent = content.replace(/\r\n/g, "\n");
+  if (!normalizedContent.startsWith("---")) {
+    return { frontmatter, body: normalizedContent };
+  }
+  const endIndex = normalizedContent.indexOf("\n---", 3);
+  if (endIndex === -1) {
+    return { frontmatter, body: normalizedContent };
+  }
+  const frontmatterStr = normalizedContent.substring(4, endIndex);
+  const body = normalizedContent.substring(endIndex + 4).trim();
+  const lines = frontmatterStr.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) {
+      const key = match[1];
+      let value = match[2].trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (key) {
+        frontmatter[key] = value;
+      }
+    }
+  }
+  return { frontmatter, body };
+}
+function convertEjsToTemplateLiteral(ejs) {
+  let hasCodeBlocks = false;
+  if (/<%((?!=|-)[\s\S]*?)%>/.test(ejs)) {
+    hasCodeBlocks = true;
+  }
+  let template = ejs.replace(/<%=\s*([^%]+?)\s*%>/g, "${$1}").replace(/<%-\s*([^%]+?)\s*%>/g, "${$1}").replace(/<%[\s\S]*?%>/g, "/* EJS code block - manual conversion needed */");
+  template = template.replace(/`/g, "\\`");
+  return { template, hasCodeBlocks };
+}
+function extractEjsVariables(ejs) {
+  const variables = /* @__PURE__ */ new Set();
+  const skipTokens = ["h", "locals", "helpers", "if", "else", "for", "while", "true", "false", "null", "undefined"];
+  const regex = /<%[=-]\s*([^%]+?)\s*%>/g;
+  let match;
+  while ((match = regex.exec(ejs)) !== null) {
+    const expression = match[1];
+    if (!expression) continue;
+    const tokenMatches = expression.matchAll(/\b(\w+)\b/g);
+    for (const tokenMatch of tokenMatches) {
+      const token = tokenMatch[1];
+      if (!token) continue;
+      if (skipTokens.includes(token)) continue;
+      const tokenEndIndex = tokenMatch.index + tokenMatch[0].length;
+      const afterToken = expression.slice(tokenEndIndex).trimStart();
+      if (!afterToken.startsWith("(")) {
+        variables.add(token);
+      }
+    }
+  }
+  return Array.from(variables);
+}
+function parsePromptJs(content) {
+  const prompts = [];
+  const objectRegex = /\{[^{}]*\}/g;
+  let objMatch;
+  while ((objMatch = objectRegex.exec(content)) !== null) {
+    const promptStr = objMatch[0];
+    const typeMatch = promptStr.match(/type\s*:\s*['"](\w+)['"]/);
+    const nameMatch = promptStr.match(/name\s*:\s*['"](\w+)['"]/);
+    const type = typeMatch?.[1];
+    const name = nameMatch?.[1];
+    if (type && name) {
+      const messageMatch = promptStr.match(/message\s*:\s*['"]([^'"]+)['"]/);
+      const message = messageMatch?.[1];
+      const initialMatch = promptStr.match(/initial\s*:\s*['"]?([^'",}]+)['"]?/);
+      const initial = initialMatch?.[1]?.trim();
+      prompts.push({
+        type,
+        name,
+        message,
+        initial
+      });
+    }
+  }
+  return prompts;
+}
+function promptsToZod2(prompts) {
+  if (prompts.length === 0) {
+    return "z.object({})";
+  }
+  const fields = prompts.map((prompt) => {
+    let zodType = PROMPT_TYPE_MAP2[prompt.type] || "z.string()";
+    if (prompt.message) {
+      zodType += `.describe('${escapeStringLiteral2(prompt.message)}')`;
+    }
+    if (prompt.initial !== void 0) {
+      if (Array.isArray(prompt.initial)) {
+        const items = prompt.initial.map(
+          (item) => typeof item === "string" ? `'${escapeStringLiteral2(item)}'` : String(item)
+        );
+        zodType += `.default([${items.join(", ")}])`;
+      } else if (typeof prompt.initial === "string") {
+        zodType += `.default('${escapeStringLiteral2(prompt.initial)}')`;
+      } else if (typeof prompt.initial === "number") {
+        zodType += `.default(${prompt.initial})`;
+      } else if (typeof prompt.initial === "boolean") {
+        zodType += `.default(${prompt.initial})`;
+      }
+    }
+    return `  ${prompt.name}: ${zodType}`;
+  });
+  return `z.object({
+${fields.join(",\n")}
+})`;
+}
+async function scanHygenGenerators(templatesDir) {
+  const generators = /* @__PURE__ */ new Map();
+  if (!await pathExists2(templatesDir)) {
+    return generators;
+  }
+  try {
+    const entries = await readdir(templatesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const generatorName = entry.name;
+        const generatorPath = join2(templatesDir, generatorName);
+        try {
+          const actionEntries = await readdir(generatorPath, { withFileTypes: true });
+          const actions = actionEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+          if (actions.length > 0) {
+            generators.set(generatorName, actions);
+          }
+        } catch (err) {
+          console.warn(`Warning: Failed to scan generator '${generatorName}' at ${generatorPath}: ${toErrorMessage(err)}`);
+        }
+      }
+    }
+  } catch (err) {
+    console.warn(`Warning: Failed to scan templates directory: ${toErrorMessage(err)}`);
+  }
+  return generators;
+}
+function generateAtomicGenerator2(parsed) {
+  const zodSchema = promptsToZod2(parsed.prompts);
+  const allVariables = /* @__PURE__ */ new Set();
+  for (const prompt of parsed.prompts) {
+    allVariables.add(prompt.name);
+  }
+  for (const template of parsed.templates) {
+    const vars = extractEjsVariables(template.body);
+    for (const v of vars) {
+      allVariables.add(v);
+    }
+  }
+  const paramNames = Array.from(allVariables);
+  const destructure = paramNames.length > 0 ? `{ ${paramNames.join(", ")} }` : "_params";
+  const templateOutputs = [];
+  const convertedBodies = [];
+  for (const template of parsed.templates) {
+    const { template: convertedBody, hasCodeBlocks } = convertEjsToTemplateLiteral(template.body);
+    const outputPath = template.frontmatter["to"] ? convertEjsToTemplateLiteral(template.frontmatter["to"]).template : template.filename;
+    templateOutputs.push(`  // Output: ${outputPath}`);
+    if (hasCodeBlocks) {
+      templateOutputs.push(`  // WARNING: Contains EJS code blocks that need manual conversion`);
+    }
+    convertedBodies.push(`// --- ${template.filename} ---
+${convertedBody}`);
+  }
+  if (templateOutputs.length === 0) {
+    templateOutputs.push("  // No templates found");
+  }
+  const combinedBodies = convertedBodies.length > 0 ? convertedBodies.join("\n\n") : "// No templates found";
+  const templateFn = `(${destructure}) => {
+${templateOutputs.join("\n")}
+  return \`
+${combinedBodies}
+\`;
+}`;
+  const safeName = escapeStringLiteral2(parsed.name);
+  const safeAction = escapeStringLiteral2(parsed.action);
+  const safeDescription = escapeStringLiteral2(parsed.description || `Generator for ${parsed.name}/${parsed.action}`);
+  return `/**
+ * Atomic generator: ${safeName}/${safeAction}
+ *
+ * Imported from Hygen generator.
+ *
+ * @module generators/${safeName}-${safeAction}
+ */
+
+import { z } from 'atomism';
+
+/**
+ * Generator parameters schema.
+ *
+ * Converted from Hygen prompts:
+${parsed.prompts.map((p) => ` * - ${sanitizeJsDocContent(p.name)}: ${sanitizeJsDocContent(p.type)}${p.message ? ` (${sanitizeJsDocContent(p.message)})` : ""}`).join("\n")}
+ */
+export const paramsSchema = ${zodSchema};
+
+export type Params = z.infer<typeof paramsSchema>;
+
+/**
+ * Template function.
+ *
+ * Converted from Hygen templates:
+${parsed.templates.map((t) => ` * - ${sanitizeJsDocContent(t.filename)}: ${sanitizeJsDocContent(t.frontmatter["to"] || "inline")}`).join("\n")}
+ */
+export const template = ${templateFn};
+
+/**
+ * Generator metadata.
+ */
+export const generator = {
+  name: '${safeName}-${safeAction}',
+  description: '${safeDescription}',
+  params: paramsSchema,
+  template,
+  language: 'typescript' as const,
+};
+
+export default generator;
+`;
+}
+async function importHygenGenerator(options) {
+  const {
+    projectRoot,
+    generatorName,
+    actionName,
+    outputDir = "generators",
+    overwrite = false
+  } = options;
+  const result = {
+    success: false,
+    mappings: [],
+    warnings: [],
+    errors: []
+  };
+  const templatesDir = join2(projectRoot, "_templates");
+  if (!await pathExists2(templatesDir)) {
+    result.errors.push("No _templates directory found in project root");
+    return result;
+  }
+  const generators = await scanHygenGenerators(templatesDir);
+  if (!generators.has(generatorName)) {
+    result.errors.push(
+      `Generator '${generatorName}' not found. Available: ${Array.from(generators.keys()).join(", ") || "none"}`
+    );
+    return result;
+  }
+  const actions = generators.get(generatorName);
+  let targetAction = actionName;
+  if (!targetAction) {
+    if (actions.length === 1) {
+      targetAction = actions[0];
+    } else {
+      result.errors.push(
+        `Multiple actions available for '${generatorName}'. Specify one: ${actions.join(", ")}`
+      );
+      return result;
+    }
+  }
+  if (!actions.includes(targetAction)) {
+    result.errors.push(
+      `Action '${targetAction}' not found for generator '${generatorName}'. Available: ${actions.join(", ")}`
+    );
+    return result;
+  }
+  const actionDir = join2(templatesDir, generatorName, targetAction);
+  const templates = [];
+  const prompts = [];
+  try {
+    const files = await readdir(actionDir);
+    for (const file of files) {
+      const filePath = join2(actionDir, file);
+      if (file === "prompt.js" || file === "prompt.cjs" || file === "prompt.mjs") {
+        const content = await readFile2(filePath, "utf-8");
+        const parsedPrompts = parsePromptJs(content);
+        prompts.push(...parsedPrompts);
+        for (const prompt of parsedPrompts) {
+          result.mappings.push({
+            source: `prompt:${prompt.name}`,
+            target: `params.${prompt.name}`,
+            type: "prompt",
+            notes: `${prompt.type} \u2192 ${PROMPT_TYPE_MAP2[prompt.type] || "z.string()"}`
+          });
+        }
+      } else if (file.endsWith(".ejs.t") || file.endsWith(".t")) {
+        const content = await readFile2(filePath, "utf-8");
+        const { frontmatter, body } = parseFrontmatter(content);
+        templates.push({
+          filename: file,
+          frontmatter,
+          body,
+          outputPath: frontmatter["to"]
+        });
+        result.mappings.push({
+          source: `template:${file}`,
+          target: frontmatter["to"] || "inline",
+          type: "template",
+          notes: frontmatter["to"] ? `to: ${frontmatter["to"]}` : void 0
+        });
+        if (/<%((?!=|-)[\s\S]*?)%>/.test(body)) {
+          result.warnings.push(
+            `Template '${file}' contains EJS code blocks that need manual conversion`
+          );
+        }
+      }
+    }
+  } catch (err) {
+    result.errors.push(`Failed to read templates: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const parsed = {
+    name: generatorName,
+    action: targetAction,
+    prompts,
+    templates
+  };
+  const atomicGenerator = generateAtomicGenerator2(parsed);
+  const outputName = `${generatorName}-${targetAction}`;
+  const safeOutputName = basename2(outputName);
+  if (safeOutputName !== outputName || outputName.includes("..")) {
+    result.errors.push(
+      `Invalid generator name '${outputName}': must be a simple filename without path components`
+    );
+    return result;
+  }
+  const outputPath = join2(projectRoot, outputDir);
+  try {
+    await mkdir2(outputPath, { recursive: true });
+  } catch (err) {
+    result.errors.push(`Failed to create output directory: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const generatorPath = join2(outputPath, `${safeOutputName}.ts`);
+  if (await pathExists2(generatorPath) && !overwrite) {
+    result.errors.push(
+      `Generator file already exists: ${generatorPath}. Use --overwrite to replace.`
+    );
+    return result;
+  }
+  try {
+    await writeFile2(generatorPath, atomicGenerator, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to write generator: ${toErrorMessage(err)}`);
+    return result;
+  }
+  if (prompts.length === 0) {
+    result.warnings.push("No prompts found - generator will have empty params");
+  }
+  if (templates.length === 0) {
+    result.warnings.push("No templates found - template function is placeholder");
+  }
+  result.success = true;
+  result.generatorPath = generatorPath;
+  return result;
+}
+
+// src/importer/yeoman.ts
+import { join as join3, basename as basename3 } from "path";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir as readdir2 } from "fs/promises";
+
+// src/importer/utils.ts
+import { access as access3 } from "fs/promises";
+async function pathExists3(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function escapeStringLiteral3(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function sanitizeJsDocContent2(str) {
+  return str.replace(/\*\//g, "*\\/").replace(/\/\*/g, "/\\*");
+}
+
+// src/importer/yeoman.ts
+var PROMPT_TYPE_MAP3 = {
+  input: "z.string()",
+  number: "z.number()",
+  confirm: "z.boolean()",
+  list: "z.string()",
+  rawlist: "z.string()",
+  expand: "z.string()",
+  checkbox: "z.array(z.string())",
+  password: "z.string()",
+  editor: "z.string()"
+};
+function parseYeomanPrompts(content) {
+  const prompts = [];
+  const warnings = [];
+  const promptArrayMatch = content.match(/this\.prompt\s*\(\s*\[([\s\S]*?)\]\s*\)/);
+  if (!promptArrayMatch) {
+    return { prompts, warnings };
+  }
+  const promptArray = promptArrayMatch[1];
+  const objectRegex = /\{[^{}]*\}/g;
+  let objMatch;
+  while ((objMatch = objectRegex.exec(promptArray)) !== null) {
+    const promptStr = objMatch[0];
+    const typeMatch = promptStr.match(/type\s*:\s*['"](\w+)['"]/);
+    const nameMatch = promptStr.match(/name\s*:\s*['"](\w+)['"]/);
+    const type = typeMatch?.[1];
+    const name = nameMatch?.[1];
+    if (type && name) {
+      const messageMatch = promptStr.match(/message\s*:\s*['"]([^'"]+)['"]/);
+      const defaultMatch = promptStr.match(/default\s*:\s*(?:'([^']*)'|"([^"]*)"|(\w+))/);
+      prompts.push({
+        type,
+        name,
+        message: messageMatch?.[1],
+        default: (defaultMatch?.[1] ?? defaultMatch?.[2] ?? defaultMatch?.[3])?.trim()
+      });
+    }
+  }
+  const simpleObjectCount = (promptArray.match(/\{[^{}]*\}/g) || []).length;
+  const nestedBraceCount = (promptArray.match(/\{/g) || []).length;
+  if (nestedBraceCount > simpleObjectCount) {
+    warnings.push(
+      "Some prompts with nested objects (when/filter/validate functions) may not have been fully parsed. Manual review recommended."
+    );
+  }
+  return { prompts, warnings };
+}
+function parseYeomanMethods(content) {
+  const methods = [];
+  const lifecycleMethods = [
+    "initializing",
+    "prompting",
+    "configuring",
+    "default",
+    "writing",
+    "conflicts",
+    "install",
+    "end"
+  ];
+  for (const method of lifecycleMethods) {
+    const patterns = [
+      new RegExp(`${method}\\s*\\(`),
+      // method()
+      new RegExp(`${method}\\s*:\\s*function`),
+      // method: function
+      new RegExp(`${method}\\s*:\\s*async`),
+      // method: async
+      new RegExp(`async\\s+${method}\\s*\\(`)
+      // async method()
+    ];
+    if (patterns.some((p) => p.test(content))) {
+      methods.push(method);
+    }
+  }
+  return methods;
+}
+function promptsToZod3(prompts) {
+  if (prompts.length === 0) {
+    return "z.object({})";
+  }
+  const fields = prompts.map((prompt) => {
+    let zodType = PROMPT_TYPE_MAP3[prompt.type] || "z.string()";
+    if (prompt.message) {
+      zodType += `.describe('${escapeStringLiteral3(prompt.message)}')`;
+    }
+    if (prompt.default !== void 0) {
+      if (Array.isArray(prompt.default)) {
+        const items = prompt.default.map(
+          (item) => typeof item === "string" ? `'${escapeStringLiteral3(item)}'` : String(item)
+        );
+        zodType += `.default([${items.join(", ")}])`;
+      } else if (typeof prompt.default === "string") {
+        zodType += `.default('${escapeStringLiteral3(prompt.default)}')`;
+      } else if (typeof prompt.default === "number") {
+        zodType += `.default(${prompt.default})`;
+      } else if (typeof prompt.default === "boolean") {
+        zodType += `.default(${prompt.default})`;
+      }
+    }
+    return `  ${prompt.name}: ${zodType}`;
+  });
+  return `z.object({
+${fields.join(",\n")}
+})`;
+}
+async function scanYeomanGenerators(projectRoot) {
+  const generators = /* @__PURE__ */ new Map();
+  const generatorsDir = join3(projectRoot, "generators");
+  if (await pathExists3(generatorsDir)) {
+    try {
+      const entries = await readdir2(generatorsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const indexPath = join3(generatorsDir, entry.name, "index.js");
+          if (await pathExists3(indexPath)) {
+            generators.set(entry.name, indexPath);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn(`Warning: Failed to scan generators directory: ${toErrorMessage(err)}`);
+    }
+  }
+  const nodeModulesDir = join3(projectRoot, "node_modules");
+  if (await pathExists3(nodeModulesDir)) {
+    try {
+      const entries = await readdir2(nodeModulesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith("generator-")) {
+          const genName = entry.name.replace("generator-", "");
+          const indexPath = join3(nodeModulesDir, entry.name, "generators", "app", "index.js");
+          if (await pathExists3(indexPath)) {
+            generators.set(genName, indexPath);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn(`Warning: Failed to scan node_modules: ${toErrorMessage(err)}`);
+    }
+  }
+  return generators;
+}
+function generateAtomicGenerator3(parsed) {
+  const zodSchema = promptsToZod3(parsed.prompts);
+  const paramNames = parsed.prompts.map((p) => p.name);
+  const destructure = paramNames.length > 0 ? `{ ${paramNames.join(", ")} }` : "_";
+  const safeName = escapeStringLiteral3(parsed.name);
+  const safeDescription = escapeStringLiteral3(parsed.description || `Generator for ${parsed.name}`);
+  return `/**
+ * Atomic generator: ${safeName}
+ *
+ * Imported from Yeoman generator.
+ *
+ * @module generators/${safeName}
+ */
+
+import { z } from 'atomism';
+
+/**
+ * Generator parameters schema.
+ *
+ * Converted from Yeoman prompts:
+${parsed.prompts.map((p) => ` * - ${sanitizeJsDocContent2(p.name)}: ${sanitizeJsDocContent2(p.type)}${p.message ? ` (${sanitizeJsDocContent2(p.message)})` : ""}`).join("\n")}
+ */
+export const paramsSchema = ${zodSchema};
+
+export type Params = z.infer<typeof paramsSchema>;
+
+/**
+ * Template function.
+ *
+ * Original Yeoman methods: ${parsed.methods.join(", ") || "none detected"}
+ */
+export const template = (${destructure}: Params) => {
+  // TODO: Implement template based on Yeoman generator
+  // Original lifecycle methods: ${parsed.methods.join(", ") || "none"}
+  return \`
+// Generated from Yeoman generator: ${safeName}
+// Parameters: ${paramNames.join(", ") || "none"}
+\`;
+};
+
+/**
+ * Generator metadata.
+ */
+export const generator = {
+  name: '${safeName}',
+  description: '${safeDescription}',
+  params: paramsSchema,
+  template,
+  language: 'typescript' as const,
+};
+
+export default generator;
+`;
+}
+async function importYeomanGenerator(options) {
+  const {
+    projectRoot,
+    generatorName,
+    outputDir = "generators",
+    overwrite = false
+  } = options;
+  const result = {
+    success: false,
+    mappings: [],
+    warnings: [],
+    errors: []
+  };
+  const safeGeneratorName = basename3(generatorName);
+  if (safeGeneratorName !== generatorName || generatorName.includes("..")) {
+    result.errors.push(
+      `Invalid generator name '${generatorName}': must be a simple name without path components`
+    );
+    return result;
+  }
+  const generators = await scanYeomanGenerators(projectRoot);
+  if (!generators.has(generatorName)) {
+    result.errors.push(
+      `Generator '${generatorName}' not found. Available: ${Array.from(generators.keys()).join(", ") || "none"}`
+    );
+    return result;
+  }
+  const generatorPath = generators.get(generatorName);
+  let content;
+  try {
+    content = await readFile3(generatorPath, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to read generator: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const { prompts, warnings: promptWarnings } = parseYeomanPrompts(content);
+  const methods = parseYeomanMethods(content);
+  result.warnings.push(...promptWarnings);
+  for (const prompt of prompts) {
+    result.mappings.push({
+      source: `prompt:${prompt.name}`,
+      target: `params.${prompt.name}`,
+      type: "prompt",
+      notes: `${prompt.type} \u2192 ${PROMPT_TYPE_MAP3[prompt.type] || "z.string()"}`
+    });
+  }
+  for (const method of methods) {
+    result.mappings.push({
+      source: `method:${method}`,
+      target: "template function",
+      type: "method",
+      notes: "Lifecycle method needs manual conversion"
+    });
+  }
+  const parsed = {
+    name: generatorName,
+    prompts,
+    methods
+  };
+  const atomicGenerator = generateAtomicGenerator3(parsed);
+  const outputPath = join3(projectRoot, outputDir);
+  try {
+    await mkdir3(outputPath, { recursive: true });
+  } catch (err) {
+    result.errors.push(`Failed to create output directory: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const outputFilePath = join3(outputPath, `${safeGeneratorName}.ts`);
+  if (await pathExists3(outputFilePath) && !overwrite) {
+    result.errors.push(
+      `Generator file already exists: ${outputFilePath}. Use --overwrite to replace.`
+    );
+    return result;
+  }
+  try {
+    await writeFile3(outputFilePath, atomicGenerator, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to write generator: ${toErrorMessage(err)}`);
+    return result;
+  }
+  if (prompts.length === 0) {
+    result.warnings.push("No prompts found - generator will have empty params");
+  }
+  if (methods.length > 0) {
+    result.warnings.push(
+      `Yeoman lifecycle methods (${methods.join(", ")}) need manual conversion to template function`
+    );
+  }
+  result.success = true;
+  result.generatorPath = outputFilePath;
+  return result;
+}
+
+// src/importer/cookiecutter.ts
+import { join as join4, basename as basename4, relative } from "path";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4, readdir as readdir3 } from "fs/promises";
+function parseCookiecutterJson(content) {
+  const variables = [];
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch {
+    return variables;
+  }
+  for (const [key, value] of Object.entries(config)) {
+    if (key.startsWith("_")) continue;
+    const variable = {
+      name: key
+    };
+    if (Array.isArray(value)) {
+      variable.choices = value.map(String);
+      variable.default = value[0];
+    } else {
+      variable.default = value;
+    }
+    variables.push(variable);
+  }
+  return variables;
+}
+async function findTemplateFiles(dir, baseDir, warnings) {
+  const files = [];
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join4(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "__pycache__" || entry.name === ".git") continue;
+        const subFiles = await findTemplateFiles(fullPath, baseDir, warnings);
+        files.push(...subFiles);
+      } else {
+        files.push(relative(baseDir, fullPath));
+      }
+    }
+  } catch (err) {
+    const message = `Failed to scan directory ${dir}: ${toErrorMessage(err)}`;
+    if (warnings) {
+      warnings.push(message);
+    }
+  }
+  return files;
+}
+function variablesToZod(variables) {
+  if (variables.length === 0) {
+    return "z.object({})";
+  }
+  const fields = variables.map((variable) => {
+    let zodType;
+    if (variable.choices && variable.choices.length > 0) {
+      const choices = variable.choices.map((c) => `'${escapeStringLiteral3(c)}'`);
+      zodType = `z.enum([${choices.join(", ")}])`;
+    } else if (typeof variable.default === "boolean") {
+      zodType = "z.boolean()";
+    } else if (typeof variable.default === "number") {
+      zodType = "z.number()";
+    } else {
+      zodType = "z.string()";
+    }
+    if (variable.default !== void 0 && !variable.choices) {
+      if (typeof variable.default === "string") {
+        zodType += `.default('${escapeStringLiteral3(variable.default)}')`;
+      } else if (typeof variable.default === "number" || typeof variable.default === "boolean") {
+        zodType += `.default(${variable.default})`;
+      }
+    }
+    return `  ${variable.name}: ${zodType}`;
+  });
+  return `z.object({
+${fields.join(",\n")}
+})`;
+}
+function generateAtomicGenerator4(parsed) {
+  const zodSchema = variablesToZod(parsed.variables);
+  const paramNames = parsed.variables.map((v) => v.name);
+  const destructure = paramNames.length > 0 ? `{ ${paramNames.join(", ")} }` : "_";
+  const safeName = escapeStringLiteral3(parsed.name);
+  const safeDescription = escapeStringLiteral3(parsed.description || `Generator for ${parsed.name}`);
+  return `/**
+ * Atomic generator: ${safeName}
+ *
+ * Imported from Cookiecutter template.
+ *
+ * @module generators/${safeName}
+ */
+
+import { z } from 'atomism';
+
+/**
+ * Generator parameters schema.
+ *
+ * Converted from cookiecutter.json:
+${parsed.variables.map((v) => ` * - ${sanitizeJsDocContent2(v.name)}: ${v.choices ? `enum(${v.choices.slice(0, 3).join(", ")}${v.choices.length > 3 ? "..." : ""})` : typeof v.default}`).join("\n")}
+ */
+export const paramsSchema = ${zodSchema};
+
+export type Params = z.infer<typeof paramsSchema>;
+
+/**
+ * Template function.
+ *
+ * Template files: ${parsed.templateFiles.length}
+${parsed.templateFiles.slice(0, 5).map((f) => ` * - ${sanitizeJsDocContent2(f)}`).join("\n")}${parsed.templateFiles.length > 5 ? "\n * - ..." : ""}
+ */
+export const template = (${destructure}: Params) => {
+  // TODO: Implement template based on Cookiecutter files
+  // Original template files: ${parsed.templateFiles.length}
+  return \`
+// Generated from Cookiecutter template: ${safeName}
+// Parameters: ${paramNames.join(", ") || "none"}
+\`;
+};
+
+/**
+ * Generator metadata.
+ */
+export const generator = {
+  name: '${safeName}',
+  description: '${safeDescription}',
+  params: paramsSchema,
+  template,
+  language: 'typescript' as const,
+};
+
+export default generator;
+`;
+}
+async function importCookiecutterTemplate(options) {
+  const {
+    projectRoot,
+    templatePath,
+    outputDir = "generators",
+    overwrite = false
+  } = options;
+  const result = {
+    success: false,
+    mappings: [],
+    warnings: [],
+    errors: []
+  };
+  const fullTemplatePath = join4(projectRoot, templatePath);
+  const cookiecutterJsonPath = join4(fullTemplatePath, "cookiecutter.json");
+  if (!await pathExists3(cookiecutterJsonPath)) {
+    result.errors.push(`No cookiecutter.json found at ${templatePath}`);
+    return result;
+  }
+  let cookiecutterContent;
+  try {
+    cookiecutterContent = await readFile4(cookiecutterJsonPath, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to read cookiecutter.json: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const variables = parseCookiecutterJson(cookiecutterContent);
+  for (const variable of variables) {
+    result.mappings.push({
+      source: `variable:${variable.name}`,
+      target: `params.${variable.name}`,
+      type: "variable",
+      notes: variable.choices ? `enum with ${variable.choices.length} choices` : variable.default !== void 0 ? `default: ${variable.default}` : "no default"
+    });
+  }
+  const templateFiles = [];
+  try {
+    const entries = await readdir3(fullTemplatePath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.includes("{{")) {
+        const templateDir = join4(fullTemplatePath, entry.name);
+        const files = await findTemplateFiles(templateDir, templateDir, result.warnings);
+        templateFiles.push(...files);
+      }
+    }
+  } catch (err) {
+    result.warnings.push(`Could not scan template files: ${toErrorMessage(err)}`);
+  }
+  for (const file of templateFiles) {
+    result.mappings.push({
+      source: `template:${file}`,
+      target: "template output",
+      type: "template"
+    });
+  }
+  const templateName = basename4(templatePath).replace(/^cookiecutter-/, "");
+  const safeTemplateName = basename4(templateName);
+  if (safeTemplateName !== templateName || templateName.includes("..")) {
+    result.errors.push(
+      `Invalid template name '${templateName}': must be a simple name without path components`
+    );
+    return result;
+  }
+  const parsed = {
+    name: templateName,
+    variables,
+    templateFiles
+  };
+  const atomicGenerator = generateAtomicGenerator4(parsed);
+  const outputPath = join4(projectRoot, outputDir);
+  try {
+    await mkdir4(outputPath, { recursive: true });
+  } catch (err) {
+    result.errors.push(`Failed to create output directory: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const outputFilePath = join4(outputPath, `${safeTemplateName}.ts`);
+  if (await pathExists3(outputFilePath) && !overwrite) {
+    result.errors.push(
+      `Generator file already exists: ${outputFilePath}. Use --overwrite to replace.`
+    );
+    return result;
+  }
+  try {
+    await writeFile4(outputFilePath, atomicGenerator, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to write generator: ${toErrorMessage(err)}`);
+    return result;
+  }
+  if (variables.length === 0) {
+    result.warnings.push("No variables found in cookiecutter.json - generator will have empty params");
+  }
+  if (templateFiles.length > 0) {
+    result.warnings.push(
+      `Jinja2 templates (${templateFiles.length} files) need manual conversion to template literals`
+    );
+  }
+  result.success = true;
+  result.generatorPath = outputFilePath;
+  return result;
+}
+
+// src/importer/script.ts
+import { join as join5, basename as basename5, extname } from "path";
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+function detectLanguage(filename) {
+  const ext = extname(filename).toLowerCase();
+  const languageMap = {
+    ".sh": "shell",
+    ".bash": "shell",
+    ".zsh": "shell",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".py": "python"
+  };
+  return languageMap[ext] || "unknown";
+}
+function extractShellVariables(content) {
+  const variables = [];
+  const seen = /* @__PURE__ */ new Set();
+  const patterns = [
+    /\$\{(\w+)\}/g,
+    // ${VAR}
+    /\$(\w+)/g,
+    // $VAR (but not $$, $?, etc.)
+    /read\s+-p\s+"[^"]*"\s+(\w+)/g
+    // read -p "prompt" VAR
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const name = match[1];
+      if (name && !seen.has(name) && !/^\d+$/.test(name)) {
+        if (!["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "?", "!", "#", "@", "*", "-", "$"].includes(name)) {
+          seen.add(name);
+          variables.push({
+            name,
+            source: "shell variable",
+            type: "string"
+          });
+        }
+      }
+    }
+  }
+  return variables;
+}
+function extractJsVariables(content) {
+  const variables = [];
+  const seen = /* @__PURE__ */ new Set();
+  const argvPattern = /process\.argv\[(\d+)\]/g;
+  let match;
+  while ((match = argvPattern.exec(content)) !== null) {
+    const index = parseInt(match[1], 10);
+    if (index >= 2) {
+      const name = `arg${index - 1}`;
+      if (!seen.has(name)) {
+        seen.add(name);
+        variables.push({
+          name,
+          source: `process.argv[${index}]`,
+          type: "string"
+        });
+      }
+    }
+  }
+  const promptPattern = /(?:name|key)\s*:\s*['"](\w+)['"]/g;
+  while ((match = promptPattern.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !seen.has(name)) {
+      seen.add(name);
+      variables.push({
+        name,
+        source: "prompt definition",
+        type: "string"
+      });
+    }
+  }
+  const envPattern = /process\.env\.(\w+)/g;
+  while ((match = envPattern.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !seen.has(name)) {
+      seen.add(name);
+      variables.push({
+        name,
+        source: "environment variable",
+        type: "string"
+      });
+    }
+  }
+  return variables;
+}
+function extractPythonVariables(content) {
+  const variables = [];
+  const seen = /* @__PURE__ */ new Set();
+  const argparsePattern = /add_argument\s*\(\s*['"]--?(\w+)['"]/g;
+  let match;
+  while ((match = argparsePattern.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !seen.has(name)) {
+      seen.add(name);
+      variables.push({
+        name,
+        source: "argparse argument",
+        type: "string"
+      });
+    }
+  }
+  const clickPattern = /@click\.option\s*\(\s*['"]--(\w+)['"]/g;
+  while ((match = clickPattern.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !seen.has(name)) {
+      seen.add(name);
+      variables.push({
+        name,
+        source: "click option",
+        type: "string"
+      });
+    }
+  }
+  const inputPattern = /(\w+)\s*=\s*input\s*\(/g;
+  while ((match = inputPattern.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !seen.has(name)) {
+      seen.add(name);
+      variables.push({
+        name,
+        source: "input() call",
+        type: "string"
+      });
+    }
+  }
+  return variables;
+}
+function extractVariables(content, language) {
+  switch (language) {
+    case "shell":
+      return extractShellVariables(content);
+    case "javascript":
+    case "typescript":
+      return extractJsVariables(content);
+    case "python":
+      return extractPythonVariables(content);
+    default:
+      return [];
+  }
+}
+function variablesToZod2(variables) {
+  if (variables.length === 0) {
+    return "z.object({})";
+  }
+  const fields = variables.map((variable) => {
+    let zodType;
+    switch (variable.type) {
+      case "boolean":
+        zodType = "z.boolean()";
+        break;
+      case "number":
+        zodType = "z.number()";
+        break;
+      default:
+        zodType = "z.string()";
+    }
+    zodType += `.describe('${escapeStringLiteral3(variable.source)}')`;
+    return `  ${variable.name}: ${zodType}`;
+  });
+  return `z.object({
+${fields.join(",\n")}
+})`;
+}
+function generateAtomicGenerator5(parsed) {
+  const zodSchema = variablesToZod2(parsed.variables);
+  const paramNames = parsed.variables.map((v) => v.name);
+  const destructure = paramNames.length > 0 ? `{ ${paramNames.join(", ")} }` : "_";
+  const safeName = escapeStringLiteral3(parsed.name);
+  return `/**
+ * Atomic generator: ${safeName}
+ *
+ * Imported from custom ${parsed.language} script.
+ *
+ * @module generators/${safeName}
+ */
+
+import { z } from 'atomism';
+
+/**
+ * Generator parameters schema.
+ *
+ * Detected variables from script:
+${parsed.variables.map((v) => ` * - ${sanitizeJsDocContent2(v.name)}: ${sanitizeJsDocContent2(v.source)}`).join("\n") || " * (none detected)"}
+ */
+export const paramsSchema = ${zodSchema};
+
+export type Params = z.infer<typeof paramsSchema>;
+
+/**
+ * Template function.
+ *
+ * Original script language: ${parsed.language}
+ * Manual conversion required for script logic.
+ */
+export const template = (${destructure}: Params) => {
+  // TODO: Implement template based on original script
+  // Original script: ${safeName}
+  // Language: ${parsed.language}
+  return \`
+// Generated from custom script: ${safeName}
+// Parameters: ${paramNames.join(", ") || "none"}
+\`;
+};
+
+/**
+ * Generator metadata.
+ */
+export const generator = {
+  name: '${safeName}',
+  description: 'Generator imported from custom ${parsed.language} script',
+  params: paramsSchema,
+  template,
+  language: 'typescript' as const,
+};
+
+export default generator;
+`;
+}
+async function importScript(options) {
+  const {
+    projectRoot,
+    scriptPath,
+    outputDir = "generators",
+    overwrite = false
+  } = options;
+  const result = {
+    success: false,
+    mappings: [],
+    warnings: [],
+    errors: []
+  };
+  const scriptName = basename5(scriptPath, extname(scriptPath));
+  if (!/^[\w-]+$/.test(scriptName)) {
+    result.errors.push(
+      `Invalid script name '${scriptName}': must contain only alphanumeric characters, dashes, and underscores`
+    );
+    return result;
+  }
+  const fullScriptPath = join5(projectRoot, scriptPath);
+  if (!await pathExists3(fullScriptPath)) {
+    result.errors.push(`Script not found: ${scriptPath}`);
+    return result;
+  }
+  let content;
+  try {
+    content = await readFile5(fullScriptPath, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to read script: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const language = detectLanguage(scriptPath);
+  if (language === "unknown") {
+    result.warnings.push(`Unknown script language for ${scriptPath}, treating as generic`);
+  }
+  const variables = extractVariables(content, language);
+  for (const variable of variables) {
+    result.mappings.push({
+      source: `${variable.source}:${variable.name}`,
+      target: `params.${variable.name}`,
+      type: "variable",
+      notes: `Detected from ${language} script`
+    });
+  }
+  const parsed = {
+    name: scriptName,
+    language,
+    variables,
+    content
+  };
+  const atomicGenerator = generateAtomicGenerator5(parsed);
+  const outputPath = join5(projectRoot, outputDir);
+  try {
+    await mkdir5(outputPath, { recursive: true });
+  } catch (err) {
+    result.errors.push(`Failed to create output directory: ${toErrorMessage(err)}`);
+    return result;
+  }
+  const outputFilePath = join5(outputPath, `${scriptName}.ts`);
+  if (await pathExists3(outputFilePath) && !overwrite) {
+    result.errors.push(
+      `Generator file already exists: ${outputFilePath}. Use --overwrite to replace.`
+    );
+    return result;
+  }
+  try {
+    await writeFile5(outputFilePath, atomicGenerator, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to write generator: ${toErrorMessage(err)}`);
+    return result;
+  }
+  if (variables.length === 0) {
+    result.warnings.push("No variables detected - generator will have empty params. Review the original script to add parameters.");
+  }
+  result.warnings.push(
+    `Script logic needs manual conversion to template function. Original ${language} script preserved for reference.`
+  );
+  result.success = true;
+  result.generatorPath = outputFilePath;
+  return result;
+}
+
+// src/commands/import-generator.ts
+async function importGeneratorCommand(options) {
+  const projectRoot = process.cwd();
+  if (options.plop) {
+    await importFromPlop(projectRoot, options.plop, options);
+  } else if (options.hygen) {
+    await importFromHygen(projectRoot, options.hygen, options);
+  } else if (options.yeoman) {
+    await importFromYeoman(projectRoot, options.yeoman, options);
+  } else if (options.cookiecutter) {
+    await importFromCookiecutter(projectRoot, options.cookiecutter, options);
+  } else if (options.script) {
+    await importFromScript(projectRoot, options.script, options);
+  } else {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          success: false,
+          error: "Must specify a generator to import: --plop, --hygen, --yeoman, --cookiecutter, or --script"
+        })
+      );
+    } else {
+      console.error("Error: Must specify a generator to import");
+      console.error("");
+      console.error("Options:");
+      console.error("  --plop <name>         Import Plop generator");
+      console.error("  --hygen <name>        Import Hygen generator");
+      console.error("  --yeoman <name>       Import Yeoman generator");
+      console.error("  --cookiecutter <path> Import Cookiecutter template");
+      console.error("  --script <path>       Import custom script");
+    }
+    process.exit(1);
+  }
+}
+async function importFromPlop(projectRoot, generatorName, options) {
+  const result = await importPlopGenerator({
+    projectRoot,
+    generatorName,
+    outputDir: options.output,
+    overwrite: options.overwrite
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (!result.success) {
+    console.error("Import failed:");
+    for (const error of result.errors) {
+      console.error(`  \u2717 ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`\u2713 Imported Plop generator '${generatorName}'`);
+  console.log("");
+  console.log(`Output: ${result.generatorPath}`);
+  console.log("");
+  if (result.mappings.length > 0) {
+    console.log("Mappings:");
+    for (const mapping of result.mappings) {
+      const icon = mapping.type === "prompt" ? "\u{1F4DD}" : mapping.type === "action" ? "\u26A1" : "\u{1F4C4}";
+      console.log(`  ${icon} ${mapping.source} \u2192 ${mapping.target}`);
+      if (mapping.notes) {
+        console.log(`     ${mapping.notes}`);
+      }
+    }
+    console.log("");
+  }
+  if (result.warnings.length > 0) {
+    console.log("Warnings (manual review needed):");
+    for (const warning of result.warnings) {
+      console.log(`  \u26A0 ${warning}`);
+    }
+    console.log("");
+  }
+  console.log("Next steps:");
+  console.log(`  1. Review the generated file: ${result.generatorPath}`);
+  console.log("  2. Update the template function with actual logic");
+  console.log("  3. Test the generator");
+}
+async function importFromHygen(projectRoot, generatorSpec, options) {
+  const parts = generatorSpec.split("/");
+  if (parts.length > 2 || parts.some((p) => !p.trim())) {
+    const errorMsg = `Invalid format '${generatorSpec}'. Expected 'generator' or 'generator/action'.`;
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: errorMsg }));
+    } else {
+      console.error(`Error: ${errorMsg}`);
+    }
+    process.exit(1);
+  }
+  const generatorName = parts[0];
+  const actionName = parts[1];
+  const result = await importHygenGenerator({
+    projectRoot,
+    generatorName,
+    actionName,
+    outputDir: options.output,
+    overwrite: options.overwrite
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (!result.success) {
+    console.error("Import failed:");
+    for (const error of result.errors) {
+      console.error(`  \u2717 ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`\u2713 Imported Hygen generator '${generatorSpec}'`);
+  console.log("");
+  console.log(`Output: ${result.generatorPath}`);
+  console.log("");
+  if (result.mappings.length > 0) {
+    console.log("Mappings:");
+    for (const mapping of result.mappings) {
+      const icon = mapping.type === "prompt" ? "\u{1F4DD}" : mapping.type === "template" ? "\u{1F4C4}" : "\u2699\uFE0F";
+      console.log(`  ${icon} ${mapping.source} \u2192 ${mapping.target}`);
+      if (mapping.notes) {
+        console.log(`     ${mapping.notes}`);
+      }
+    }
+    console.log("");
+  }
+  if (result.warnings.length > 0) {
+    console.log("Warnings (manual review needed):");
+    for (const warning of result.warnings) {
+      console.log(`  \u26A0 ${warning}`);
+    }
+    console.log("");
+  }
+  console.log("Next steps:");
+  console.log(`  1. Review the generated file: ${result.generatorPath}`);
+  console.log("  2. Update the template function with actual logic");
+  console.log("  3. Test the generator");
+}
+async function importFromYeoman(projectRoot, generatorName, options) {
+  const result = await importYeomanGenerator({
+    projectRoot,
+    generatorName,
+    outputDir: options.output,
+    overwrite: options.overwrite
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (!result.success) {
+    console.error("Import failed:");
+    for (const error of result.errors) {
+      console.error(`  \u2717 ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`\u2713 Imported Yeoman generator '${generatorName}'`);
+  console.log("");
+  console.log(`Output: ${result.generatorPath}`);
+  console.log("");
+  if (result.mappings.length > 0) {
+    console.log("Mappings:");
+    for (const mapping of result.mappings) {
+      const icon = mapping.type === "prompt" ? "\u{1F4DD}" : mapping.type === "method" ? "\u2699\uFE0F" : "\u{1F4C4}";
+      console.log(`  ${icon} ${mapping.source} \u2192 ${mapping.target}`);
+      if (mapping.notes) {
+        console.log(`     ${mapping.notes}`);
+      }
+    }
+    console.log("");
+  }
+  if (result.warnings.length > 0) {
+    console.log("Warnings (manual review needed):");
+    for (const warning of result.warnings) {
+      console.log(`  \u26A0 ${warning}`);
+    }
+    console.log("");
+  }
+  console.log("Next steps:");
+  console.log(`  1. Review the generated file: ${result.generatorPath}`);
+  console.log("  2. Update the template function with actual logic");
+  console.log("  3. Test the generator");
+}
+async function importFromCookiecutter(projectRoot, templatePath, options) {
+  const result = await importCookiecutterTemplate({
+    projectRoot,
+    templatePath,
+    outputDir: options.output,
+    overwrite: options.overwrite
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (!result.success) {
+    console.error("Import failed:");
+    for (const error of result.errors) {
+      console.error(`  \u2717 ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`\u2713 Imported Cookiecutter template '${templatePath}'`);
+  console.log("");
+  console.log(`Output: ${result.generatorPath}`);
+  console.log("");
+  if (result.mappings.length > 0) {
+    console.log("Mappings:");
+    for (const mapping of result.mappings) {
+      const icon = mapping.type === "variable" ? "\u{1F4DD}" : "\u{1F4C4}";
+      console.log(`  ${icon} ${mapping.source} \u2192 ${mapping.target}`);
+      if (mapping.notes) {
+        console.log(`     ${mapping.notes}`);
+      }
+    }
+    console.log("");
+  }
+  if (result.warnings.length > 0) {
+    console.log("Warnings (manual review needed):");
+    for (const warning of result.warnings) {
+      console.log(`  \u26A0 ${warning}`);
+    }
+    console.log("");
+  }
+  console.log("Next steps:");
+  console.log(`  1. Review the generated file: ${result.generatorPath}`);
+  console.log("  2. Convert Jinja2 templates to template literals");
+  console.log("  3. Test the generator");
+}
+async function importFromScript(projectRoot, scriptPath, options) {
+  const result = await importScript({
+    projectRoot,
+    scriptPath,
+    outputDir: options.output,
+    overwrite: options.overwrite
+  });
+  if (options.json) {
+    console.log(JSON.stringify(result));
+    if (!result.success) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (!result.success) {
+    console.error("Import failed:");
+    for (const error of result.errors) {
+      console.error(`  \u2717 ${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`\u2713 Imported custom script '${scriptPath}'`);
+  console.log("");
+  console.log(`Output: ${result.generatorPath}`);
+  console.log("");
+  if (result.mappings.length > 0) {
+    console.log("Mappings:");
+    for (const mapping of result.mappings) {
+      const icon = mapping.type === "command" ? "\u2699\uFE0F" : mapping.type === "file" ? "\u{1F4C4}" : "\u{1F4DD}";
+      console.log(`  ${icon} ${mapping.source} \u2192 ${mapping.target}`);
+      if (mapping.notes) {
+        console.log(`     ${mapping.notes}`);
+      }
+    }
+    console.log("");
+  }
+  if (result.warnings.length > 0) {
+    console.log("Warnings (manual review needed):");
+    for (const warning of result.warnings) {
+      console.log(`  \u26A0 ${warning}`);
+    }
+    console.log("");
+  }
+  console.log("Next steps:");
+  console.log(`  1. Review the generated file: ${result.generatorPath}`);
+  console.log("  2. Convert script logic to template function");
+  console.log("  3. Test the generator");
+}
+export {
+  importGeneratorCommand
+};
+//# sourceMappingURL=import-generator-4CKRBMTE.js.map