@ncoderz/awa 1.0.0 → 1.2.0

package/dist/chunk-3SSUJFKN.js

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+
+// src/core/config.ts
+import { parse } from "smol-toml";
+
+// src/types/index.ts
+var DiffError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DiffError";
+  }
+};
+var ConfigError = class extends Error {
+  constructor(message, code, filePath) {
+    super(message);
+    this.code = code;
+    this.filePath = filePath;
+    this.name = "ConfigError";
+  }
+};
+var TemplateError = class extends Error {
+  constructor(message, code, source) {
+    super(message);
+    this.code = code;
+    this.source = source;
+    this.name = "TemplateError";
+  }
+};
+var GenerationError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "GenerationError";
+  }
+};
+
+// src/utils/fs.ts
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile(path) {
+  return readFile(path, "utf-8");
+}
+async function readBinaryFile(path) {
+  return readFile(path);
+}
+async function writeTextFile(path, content) {
+  await ensureDir(dirname(path));
+  await writeFile(path, content, "utf-8");
+}
+async function* walkDirectory(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith("_")) {
+        continue;
+      }
+      yield* walkDirectory(fullPath);
+    } else if (entry.isFile()) {
+      if (entry.name.startsWith("_")) {
+        continue;
+      }
+      yield fullPath;
+    }
+  }
+}
+function getCacheDir() {
+  return join(homedir(), ".cache", "awa", "templates");
+}
+function getTemplateDir() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  if (currentDir.includes("/dist")) {
+    return join(dirname(currentDir), "templates");
+  }
+  return join(currentDir, "..", "..", "templates");
+}
+async function rmDir(dirPath) {
+  await rm(dirPath, { recursive: true, force: true });
+}
+async function deleteFile(filePath) {
+  await rm(filePath, { force: true });
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  info(message) {
+    console.log(chalk.blue("\u2139"), message);
+  }
+  success(message) {
+    console.log(chalk.green("\u2714"), message);
+  }
+  warn(message) {
+    console.warn(chalk.yellow("\u26A0"), message);
+  }
+  error(message) {
+    console.error(chalk.red("\u2716"), message);
+  }
+  fileAction(action) {
+    const { type, outputPath } = action;
+    switch (type) {
+      case "create":
+        console.log(chalk.green("  + "), chalk.dim(outputPath));
+        break;
+      case "overwrite":
+        console.log(chalk.yellow("  ~ "), chalk.dim(outputPath));
+        break;
+      case "skip-user":
+        console.log(chalk.blue("  - "), chalk.dim(outputPath), chalk.dim("(skipped)"));
+        break;
+      case "skip-empty":
+        console.log(chalk.dim("  \xB7 "), chalk.dim(outputPath), chalk.dim("(empty)"));
+        break;
+      case "skip-equal":
+        console.log(chalk.dim("  = "), chalk.dim(outputPath), chalk.dim("(unchanged)"));
+        break;
+      case "delete":
+        console.log(chalk.red("  \u2716 "), chalk.dim(outputPath), chalk.red("(deleted)"));
+        break;
+    }
+  }
+  // @awa-impl: GEN-9_AC-1, GEN-9_AC-2, GEN-9_AC-3, GEN-9_AC-4, GEN-9_AC-5, GEN-9_AC-6
+  summary(result) {
+    console.log("");
+    console.log(chalk.bold("Summary:"));
+    if (result.created === 0 && result.overwritten === 0 && result.deleted === 0) {
+      console.log(chalk.yellow("  \u26A0 No files were created, overwritten, or deleted"));
+    }
+    if (result.created > 0) {
+      console.log(chalk.green(`  Created: ${result.created}`));
+    }
+    if (result.overwritten > 0) {
+      console.log(chalk.yellow(`  Overwritten: ${result.overwritten}`));
+    }
+    if (result.deleted > 0) {
+      console.log(chalk.red(`  Deleted: ${result.deleted}`));
+    }
+    if (result.skippedEqual > 0) {
+      console.log(chalk.dim(`  Skipped (equal): ${result.skippedEqual}`));
+    }
+    if (result.skippedUser > 0) {
+      console.log(chalk.blue(`  Skipped (user): ${result.skippedUser}`));
+    }
+    if (result.skippedEmpty > 0) {
+      console.log(chalk.dim(`  Skipped (empty): ${result.skippedEmpty}`));
+    }
+    console.log("");
+  }
+  // @awa-impl: DIFF-4_AC-3
+  diffLine(line, type) {
+    switch (type) {
+      case "add":
+        console.log(chalk.green(line));
+        break;
+      case "remove":
+        console.log(chalk.red(line));
+        break;
+      case "context":
+        console.log(chalk.dim(line));
+        break;
+    }
+  }
+  // @awa-impl: DIFF-4_AC-4, DIFF-4_AC-5
+  diffSummary(result) {
+    console.log("");
+    const filesCompared = result.identical + result.modified + result.newFiles + result.extraFiles + result.binaryDiffers + result.deleteListed;
+    const differences = result.modified + result.newFiles + result.extraFiles + result.binaryDiffers + result.deleteListed;
+    console.log(chalk.bold(`${filesCompared} files compared, ${differences} differences`));
+    if (!result.hasDifferences) {
+      console.log(chalk.green("\u2714 No differences found"));
+    }
+    console.log(chalk.bold("Summary:"));
+    console.log(chalk.dim(`  Identical: ${result.identical}`));
+    if (result.modified > 0) {
+      console.log(chalk.yellow(`  Modified: ${result.modified}`));
+    }
+    if (result.newFiles > 0) {
+      console.log(chalk.green(`  New: ${result.newFiles}`));
+    }
+    if (result.extraFiles > 0) {
+      console.log(chalk.red(`  Extra: ${result.extraFiles}`));
+    }
+    if (result.binaryDiffers > 0) {
+      console.log(chalk.red(`  Binary differs: ${result.binaryDiffers}`));
+    }
+    if (result.deleteListed > 0) {
+      console.log(chalk.red(`  Delete listed: ${result.deleteListed}`));
+    }
+    console.log("");
+  }
+};
+var logger = new Logger();
+
+// src/core/config.ts
+var DEFAULT_CONFIG_PATH = ".awa.toml";
+var ConfigLoader = class {
+  // @awa-impl: CFG-1_AC-1, CFG-1_AC-2, CFG-1_AC-3, CFG-1_AC-4
+  async load(configPath) {
+    const pathToLoad = configPath ?? DEFAULT_CONFIG_PATH;
+    const exists = await pathExists(pathToLoad);
+    if (configPath && !exists) {
+      throw new ConfigError(
+        `Configuration file not found: ${configPath}`,
+        "FILE_NOT_FOUND",
+        configPath
+      );
+    }
+    if (!configPath && !exists) {
+      return null;
+    }
+    try {
+      const content = await readTextFile(pathToLoad);
+      const parsed = parse(content);
+      const config = {};
+      if (parsed.output !== void 0) {
+        if (typeof parsed.output !== "string") {
+          throw new ConfigError(
+            `Invalid type for 'output': expected string, got ${typeof parsed.output}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.output = parsed.output;
+      }
+      if (parsed.template !== void 0) {
+        if (typeof parsed.template !== "string") {
+          throw new ConfigError(
+            `Invalid type for 'template': expected string, got ${typeof parsed.template}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.template = parsed.template;
+      }
+      if (parsed.features !== void 0) {
+        if (!Array.isArray(parsed.features) || !parsed.features.every((f) => typeof f === "string")) {
+          throw new ConfigError(
+            `Invalid type for 'features': expected array of strings`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.features = parsed.features;
+      }
+      if (parsed.preset !== void 0) {
+        if (!Array.isArray(parsed.preset) || !parsed.preset.every((p) => typeof p === "string")) {
+          throw new ConfigError(
+            `Invalid type for 'preset': expected array of strings`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.preset = parsed.preset;
+      }
+      if (parsed["remove-features"] !== void 0) {
+        if (!Array.isArray(parsed["remove-features"]) || !parsed["remove-features"].every((f) => typeof f === "string")) {
+          throw new ConfigError(
+            `Invalid type for 'remove-features': expected array of strings`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config["remove-features"] = parsed["remove-features"];
+      }
+      if (parsed.force !== void 0) {
+        if (typeof parsed.force !== "boolean") {
+          throw new ConfigError(
+            `Invalid type for 'force': expected boolean, got ${typeof parsed.force}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.force = parsed.force;
+      }
+      if (parsed["dry-run"] !== void 0) {
+        if (typeof parsed["dry-run"] !== "boolean") {
+          throw new ConfigError(
+            `Invalid type for 'dry-run': expected boolean, got ${typeof parsed["dry-run"]}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config["dry-run"] = parsed["dry-run"];
+      }
+      if (parsed.delete !== void 0) {
+        if (typeof parsed.delete !== "boolean") {
+          throw new ConfigError(
+            `Invalid type for 'delete': expected boolean, got ${typeof parsed.delete}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.delete = parsed.delete;
+      }
+      if (parsed.refresh !== void 0) {
+        if (typeof parsed.refresh !== "boolean") {
+          throw new ConfigError(
+            `Invalid type for 'refresh': expected boolean, got ${typeof parsed.refresh}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.refresh = parsed.refresh;
+      }
+      if (parsed.presets !== void 0) {
+        if (parsed.presets === null || typeof parsed.presets !== "object" || Array.isArray(parsed.presets)) {
+          throw new ConfigError(
+            `Invalid type for 'presets': expected table of string arrays`,
+            "INVALID_PRESET",
+            pathToLoad
+          );
+        }
+        const defs = {};
+        for (const [presetName, value] of Object.entries(
+          parsed.presets
+        )) {
+          if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+            throw new ConfigError(
+              `Invalid preset '${presetName}': expected array of strings`,
+              "INVALID_PRESET",
+              pathToLoad
+            );
+          }
+          defs[presetName] = value;
+        }
+        config.presets = defs;
+      }
+      if (parsed["list-unknown"] !== void 0) {
+        if (typeof parsed["list-unknown"] !== "boolean") {
+          throw new ConfigError(
+            `Invalid type for 'list-unknown': expected boolean, got ${typeof parsed["list-unknown"]}`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config["list-unknown"] = parsed["list-unknown"];
+      }
+      if (parsed.check !== void 0) {
+        if (parsed.check === null || typeof parsed.check !== "object" || Array.isArray(parsed.check)) {
+          throw new ConfigError(
+            `Invalid type for 'check': expected table`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.check = parsed.check;
+      }
+      if (parsed.overlay !== void 0) {
+        if (!Array.isArray(parsed.overlay) || !parsed.overlay.every((o) => typeof o === "string")) {
+          throw new ConfigError(
+            `Invalid type for 'overlay': expected array of strings`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        config.overlay = parsed.overlay;
+      }
+      if (parsed["update-check"] !== void 0) {
+        if (parsed["update-check"] === null || typeof parsed["update-check"] !== "object" || Array.isArray(parsed["update-check"])) {
+          throw new ConfigError(
+            `Invalid type for 'update-check': expected table`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        const raw = parsed["update-check"];
+        const updateCheckConfig = {};
+        if (raw.enabled !== void 0) {
+          if (typeof raw.enabled !== "boolean") {
+            throw new ConfigError(
+              `Invalid type for 'update-check.enabled': expected boolean, got ${typeof raw.enabled}`,
+              "INVALID_TYPE",
+              pathToLoad
+            );
+          }
+          updateCheckConfig.enabled = raw.enabled;
+        }
+        if (raw.interval !== void 0) {
+          if (typeof raw.interval !== "number") {
+            throw new ConfigError(
+              `Invalid type for 'update-check.interval': expected number, got ${typeof raw.interval}`,
+              "INVALID_TYPE",
+              pathToLoad
+            );
+          }
+          updateCheckConfig.interval = raw.interval;
+        }
+        config["update-check"] = updateCheckConfig;
+      }
+      if (parsed.targets !== void 0) {
+        if (parsed.targets === null || typeof parsed.targets !== "object" || Array.isArray(parsed.targets)) {
+          throw new ConfigError(
+            `Invalid type for 'targets': expected table of target sections`,
+            "INVALID_TYPE",
+            pathToLoad
+          );
+        }
+        const targets = {};
+        for (const [targetName, targetValue] of Object.entries(
+          parsed.targets
+        )) {
+          if (targetValue === null || typeof targetValue !== "object" || Array.isArray(targetValue)) {
+            throw new ConfigError(
+              `Invalid target '${targetName}': expected table`,
+              "INVALID_TYPE",
+              pathToLoad
+            );
+          }
+          targets[targetName] = this.parseTargetSection(
+            targetValue,
+            targetName,
+            pathToLoad
+          );
+        }
+        config.targets = targets;
+      }
+      const knownKeys = /* @__PURE__ */ new Set([
+        "output",
+        "template",
+        "features",
+        "preset",
+        "remove-features",
+        "presets",
+        "force",
+        "dry-run",
+        "delete",
+        "refresh",
+        "list-unknown",
+        "check",
+        "targets",
+        "overlay",
+        "update-check"
+      ]);
+      for (const key of Object.keys(parsed)) {
+        if (!knownKeys.has(key)) {
+          logger.warn(`Unknown configuration option: '${key}'`);
+        }
+      }
+      return config;
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        throw error;
+      }
+      throw new ConfigError(
+        `Failed to parse TOML configuration: ${error instanceof Error ? error.message : String(error)}`,
+        "PARSE_ERROR",
+        pathToLoad
+      );
+    }
+  }
+  // @awa-impl: CFG-4_AC-1, CFG-4_AC-2, CFG-4_AC-3, CFG-4_AC-4
+  // @awa-impl: CLI-2_AC-2, CLI-2_AC-3, CLI-2_AC-4
+  merge(cli, file) {
+    const output = cli.output ?? file?.output;
+    if (!output) {
+      throw new ConfigError(
+        "Output directory is required. Provide it as a positional argument or in the config file.",
+        "MISSING_OUTPUT",
+        null
+      );
+    }
+    const template = cli.template ?? file?.template ?? null;
+    const features = cli.features ?? file?.features ?? [];
+    const preset = cli.preset ?? file?.preset ?? [];
+    const removeFeatures = cli.removeFeatures ?? file?.["remove-features"] ?? [];
+    const presets = file?.presets ?? {};
+    const force = cli.force ?? file?.force ?? false;
+    const dryRun = cli.dryRun ?? file?.["dry-run"] ?? false;
+    const enableDelete = cli.delete ?? file?.delete ?? false;
+    const refresh = cli.refresh ?? file?.refresh ?? false;
+    const listUnknown = cli.listUnknown ?? file?.["list-unknown"] ?? false;
+    const overlay = cli.overlay ?? file?.overlay ?? [];
+    const json = cli.json ?? false;
+    const summary = cli.summary ?? false;
+    return {
+      output,
+      template,
+      features,
+      preset,
+      removeFeatures,
+      force,
+      dryRun,
+      delete: enableDelete,
+      refresh,
+      presets,
+      listUnknown,
+      overlay,
+      json,
+      summary
+    };
+  }
+  // Parse a [targets.<name>] section, validating allowed keys and types
+  parseTargetSection(section, targetName, configPath) {
+    const target = {};
+    const allowedKeys = /* @__PURE__ */ new Set(["output", "template", "features", "preset", "remove-features"]);
+    for (const key of Object.keys(section)) {
+      if (!allowedKeys.has(key)) {
+        logger.warn(`Unknown option in target '${targetName}': '${key}'`);
+      }
+    }
+    if (section.output !== void 0) {
+      if (typeof section.output !== "string") {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.output': expected string, got ${typeof section.output}`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.output = section.output;
+    }
+    if (section.template !== void 0) {
+      if (typeof section.template !== "string") {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.template': expected string, got ${typeof section.template}`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.template = section.template;
+    }
+    if (section.features !== void 0) {
+      if (!Array.isArray(section.features) || !section.features.every((f) => typeof f === "string")) {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.features': expected array of strings`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.features = section.features;
+    }
+    if (section.preset !== void 0) {
+      if (!Array.isArray(section.preset) || !section.preset.every((p) => typeof p === "string")) {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.preset': expected array of strings`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target.preset = section.preset;
+    }
+    if (section["remove-features"] !== void 0) {
+      if (!Array.isArray(section["remove-features"]) || !section["remove-features"].every((f) => typeof f === "string")) {
+        throw new ConfigError(
+          `Invalid type for 'targets.${targetName}.remove-features': expected array of strings`,
+          "INVALID_TYPE",
+          configPath
+        );
+      }
+      target["remove-features"] = section["remove-features"];
+    }
+    return target;
+  }
+  // Resolve a target by merging target config with root config (target overrides root via nullish coalescing)
+  resolveTarget(targetName, fileConfig) {
+    const targets = fileConfig.targets;
+    if (!targets || Object.keys(targets).length === 0) {
+      throw new ConfigError(
+        "No targets defined in configuration. Add [targets.<name>] sections to .awa.toml.",
+        "NO_TARGETS",
+        null
+      );
+    }
+    const target = targets[targetName];
+    if (!target) {
+      throw new ConfigError(
+        `Unknown target: '${targetName}'. Available targets: ${Object.keys(targets).join(", ")}`,
+        "UNKNOWN_TARGET",
+        null
+      );
+    }
+    return {
+      ...fileConfig,
+      output: target.output ?? fileConfig.output,
+      template: target.template ?? fileConfig.template,
+      features: target.features ?? fileConfig.features,
+      preset: target.preset ?? fileConfig.preset,
+      "remove-features": target["remove-features"] ?? fileConfig["remove-features"],
+      targets: void 0
+      // Don't propagate targets into resolved config
+    };
+  }
+  // Get all target names from config
+  getTargetNames(fileConfig) {
+    if (!fileConfig?.targets) {
+      return [];
+    }
+    return Object.keys(fileConfig.targets);
+  }
+};
+var configLoader = new ConfigLoader();
+
+export {
+  DiffError,
+  ConfigError,
+  TemplateError,
+  GenerationError,
+  ensureDir,
+  pathExists,
+  readTextFile,
+  readBinaryFile,
+  writeTextFile,
+  walkDirectory,
+  getCacheDir,
+  getTemplateDir,
+  rmDir,
+  deleteFile,
+  logger,
+  ConfigLoader,
+  configLoader
+};
+//# sourceMappingURL=chunk-3SSUJFKN.js.map