@ncoderz/awa 0.2.0

package/dist/index.js

@@ -0,0 +1,1353 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/_generated/package_info.ts
+var PACKAGE_INFO = {
+  "name": "@ncoderz/awa",
+  "version": "0.2.0",
+  "author": "Richard Sewell <richard.sewell@ncoderz.com>",
+  "license": "MIT",
+  "description": "awa is an Agent Workflow for AIs. It is also a CLI tool to powerfully manage agent workflow files using templates."
+};
+
+// src/commands/diff.ts
+import { intro, outro } from "@clack/prompts";
+
+// 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"];
+      }
+      const knownKeys = /* @__PURE__ */ new Set([
+        "output",
+        "template",
+        "features",
+        "preset",
+        "remove-features",
+        "presets",
+        "force",
+        "dry-run",
+        "delete",
+        "refresh",
+        "list-unknown"
+      ]);
+      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;
+    return {
+      output,
+      template,
+      features,
+      preset,
+      removeFeatures,
+      force,
+      dryRun,
+      delete: enableDelete,
+      refresh,
+      presets,
+      listUnknown
+    };
+  }
+};
+var configLoader = new ConfigLoader();
+
+// src/core/differ.ts
+import { tmpdir } from "os";
+import { join as join4, relative as relative2 } from "path";
+import { structuredPatch } from "diff";
+import { isBinaryFile as detectBinaryFile } from "isbinaryfile";
+
+// src/core/delete-list.ts
+import { join as join2 } from "path";
+var DELETE_LIST_FILENAME = "_delete.txt";
+function parseDeleteList(content) {
+  const entries = [];
+  let currentFeatures;
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (line.length === 0) continue;
+    if (line.startsWith("#")) {
+      const featureMatch = line.match(/^#\s*@feature\s+(.+)$/);
+      if (featureMatch) {
+        const featureSection = featureMatch[1];
+        currentFeatures = featureSection ? featureSection.trim().split(/\s+/) : void 0;
+      } else {
+        currentFeatures = void 0;
+      }
+      continue;
+    }
+    entries.push({ path: line, features: currentFeatures });
+  }
+  return entries;
+}
+function resolveDeleteList(entries, activeFeatures) {
+  const activeSet = new Set(activeFeatures);
+  return entries.filter((e) => e.features === void 0 || !e.features.some((f) => activeSet.has(f))).map((e) => e.path);
+}
+async function loadDeleteList(templatePath) {
+  const deleteListPath = join2(templatePath, DELETE_LIST_FILENAME);
+  if (!await pathExists(deleteListPath)) {
+    return [];
+  }
+  const content = await readTextFile(deleteListPath);
+  return parseDeleteList(content);
+}
+
+// src/core/generator.ts
+import { join as join3, relative } from "path";
+
+// src/core/resolver.ts
+import { MultiSelectPrompt } from "@clack/core";
+import { isCancel, multiselect } from "@clack/prompts";
+import chalk2 from "chalk";
+var _unicode = process.platform !== "win32";
+var _s = (c, fb) => _unicode ? c : fb;
+var _CHECKED = _s("\u25FC", "[+]");
+var _UNCHECKED_A = _s("\u25FB", "[\xB7]");
+var _UNCHECKED = _s("\u25FB", "[ ]");
+var _BAR = _s("\u2502", "|");
+var _BAR_END = _s("\u2514", "-");
+function _renderDeleteItem(opt, state) {
+  const label = opt.label ?? opt.value;
+  const hint = opt.hint ? ` ${chalk2.dim(`(${opt.hint})`)}` : "";
+  switch (state) {
+    case "active":
+      return `${chalk2.cyan(_UNCHECKED_A)} ${label}${hint}`;
+    case "selected":
+      return `${chalk2.red(_CHECKED)} ${chalk2.dim(label)}${hint}`;
+    case "active-selected":
+      return `${chalk2.red(_CHECKED)} ${label}${hint}`;
+    case "cancelled":
+      return chalk2.strikethrough(chalk2.dim(label));
+    case "submitted":
+      return chalk2.dim(label);
+    default:
+      return `${chalk2.dim(_UNCHECKED)} ${chalk2.dim(label)}`;
+  }
+}
+async function deleteMultiselect(opts) {
+  const { message, options, initialValues, required = false } = opts;
+  return new MultiSelectPrompt({
+    options,
+    initialValues,
+    required,
+    render() {
+      const self = this;
+      const header = `${chalk2.gray(_BAR)}
+${chalk2.cyan(_BAR)}  ${message}
+`;
+      const getState = (opt, idx) => {
+        const active = idx === self.cursor;
+        const sel = self.value.includes(opt.value);
+        if (active && sel) return "active-selected";
+        if (sel) return "selected";
+        if (active) return "active";
+        return "inactive";
+      };
+      switch (self.state) {
+        case "submit":
+          return `${header}${chalk2.gray(_BAR)}  ` + (self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "submitted")).join(chalk2.dim(", ")) || chalk2.dim("none"));
+        case "cancel": {
+          const cancelled = self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "cancelled")).join(chalk2.dim(", "));
+          return `${header}${chalk2.gray(_BAR)}  ${cancelled.trim() ? `${cancelled}
+${chalk2.gray(_BAR)}` : chalk2.dim("none")}`;
+        }
+        default:
+          return `${header}${chalk2.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
+${chalk2.cyan(_BAR)}  `) + `
+${chalk2.cyan(_BAR_END)}
+`;
+      }
+    }
+  }).prompt();
+}
+var ConflictResolver = class {
+  // @awa-impl: GEN-4_AC-1, GEN-4_AC-2, GEN-4_AC-3
+  // @awa-impl: GEN-5_AC-1, GEN-5_AC-2, GEN-5_AC-3, GEN-5_AC-4, GEN-5_AC-5, GEN-5_AC-6, GEN-5_AC-7
+  // @awa-impl: CLI-5_AC-2, CLI-5_AC-3
+  // @awa-impl: GEN-6_AC-3
+  async resolveBatch(conflicts, force, dryRun) {
+    const identicalPaths = conflicts.filter((c) => c.newContent === c.existingContent).map((c) => c.outputPath);
+    const differentFiles = conflicts.filter((c) => c.newContent !== c.existingContent);
+    if (dryRun) {
+      return {
+        overwrite: [],
+        skip: differentFiles.map((c) => c.outputPath),
+        equal: identicalPaths
+      };
+    }
+    if (force) {
+      return {
+        overwrite: differentFiles.map((c) => c.outputPath),
+        skip: [],
+        equal: identicalPaths
+      };
+    }
+    if (differentFiles.length === 0) {
+      return {
+        overwrite: [],
+        skip: [],
+        equal: identicalPaths
+      };
+    }
+    const selected = await multiselect({
+      message: "The following files already exist. Select files to overwrite:",
+      options: differentFiles.map((c) => ({
+        value: c.outputPath,
+        label: c.outputPath
+      })),
+      initialValues: differentFiles.map((c) => c.outputPath),
+      // All selected by default (AC-5.6)
+      required: false
+    });
+    if (isCancel(selected)) {
+      process.exit(1);
+    }
+    const selectedPaths = selected;
+    const allPaths = differentFiles.map((c) => c.outputPath);
+    return {
+      overwrite: selectedPaths,
+      skip: allPaths.filter((p) => !selectedPaths.includes(p)),
+      equal: identicalPaths
+    };
+  }
+};
+var conflictResolver = new ConflictResolver();
+var DeleteResolver = class {
+  /**
+   * Prompt user to confirm which files to delete.
+   * Returns the list of absolute paths confirmed for deletion.
+   */
+  async resolveDeletes(candidates, force, dryRun) {
+    if (candidates.length === 0) {
+      return [];
+    }
+    if (dryRun) {
+      return candidates;
+    }
+    if (force) {
+      return candidates;
+    }
+    const selected = await deleteMultiselect({
+      message: "\u26A0 WARNING: The selected files will be PERMANENTLY DELETED from disk.\n  Deselect any files you want to keep. Press Enter to confirm deletion:",
+      options: candidates.map((p) => ({
+        value: p,
+        label: p
+      })),
+      initialValues: candidates,
+      required: false
+    });
+    if (isCancel(selected)) {
+      process.exit(1);
+    }
+    return selected;
+  }
+};
+var deleteResolver = new DeleteResolver();
+
+// src/core/template.ts
+import { Eta } from "eta";
+var EMPTY_FILE_MARKER = "<!-- AWA:EMPTY_FILE -->";
+var TemplateEngine = class {
+  eta = null;
+  templateDir = null;
+  compiledCache = /* @__PURE__ */ new Map();
+  // @awa-impl: TPL-8_AC-1, TPL-8_AC-2, TPL-8_AC-3, TPL-8_AC-4
+  configure(templateDir) {
+    this.templateDir = templateDir;
+    this.compiledCache.clear();
+    this.eta = new Eta({
+      views: templateDir,
+      cache: true,
+      // Enable compilation caching
+      autoEscape: false,
+      // Don't escape HTML by default
+      defaultExtension: ""
+      // No automatic extension - use exact path as specified (AC-8.2)
+    });
+  }
+  // @awa-impl: TPL-5_AC-1, TPL-5_AC-2, TPL-5_AC-3
+  // @awa-impl: TPL-6_AC-1, TPL-6_AC-2
+  // @awa-impl: TPL-7_AC-1, TPL-7_AC-2
+  // @awa-impl: TPL-11_AC-1, TPL-11_AC-2
+  async render(templatePath, context) {
+    if (!this.eta || !this.templateDir) {
+      throw new TemplateError(
+        "Template engine not configured. Call configure() first.",
+        "RENDER_ERROR"
+      );
+    }
+    try {
+      const templateContent = await readTextFile(templatePath);
+      const rendered = await this.eta.renderStringAsync(templateContent, {
+        features: context.features
+      });
+      const trimmed = rendered.trim();
+      const isEmpty = trimmed.length === 0;
+      const isEmptyFileMarker = trimmed === EMPTY_FILE_MARKER;
+      return {
+        content: rendered,
+        isEmpty,
+        isEmptyFileMarker
+      };
+    } catch (error) {
+      throw new TemplateError(
+        `Failed to render template ${templatePath}: ${error instanceof Error ? error.message : String(error)}`,
+        "RENDER_ERROR",
+        templatePath
+      );
+    }
+  }
+};
+var templateEngine = new TemplateEngine();
+
+// src/core/generator.ts
+var FileGenerator = class {
+  // @awa-impl: GEN-1_AC-1, GEN-1_AC-2, GEN-1_AC-3
+  // @awa-impl: GEN-2_AC-1, GEN-2_AC-2, GEN-2_AC-3
+  // @awa-impl: GEN-3_AC-1, GEN-3_AC-2, GEN-3_AC-3
+  async generate(options) {
+    const { templatePath, outputPath, features, force, dryRun } = options;
+    const enableDelete = options.delete;
+    templateEngine.configure(templatePath);
+    const actions = [];
+    let created = 0;
+    let overwritten = 0;
+    let deleted = 0;
+    let skippedEmpty = 0;
+    let skippedUser = 0;
+    let skippedEqual = 0;
+    const filesToProcess = [];
+    const conflicts = [];
+    try {
+      for await (const templateFile of this.walkTemplates(templatePath)) {
+        const outputFile = this.computeOutputPath(templateFile, templatePath, outputPath);
+        const result = await templateEngine.render(templateFile, { features });
+        if (result.isEmpty && !result.isEmptyFileMarker) {
+          actions.push({
+            type: "skip-empty",
+            sourcePath: templateFile,
+            outputPath: outputFile
+          });
+          skippedEmpty++;
+          continue;
+        }
+        const content = result.isEmptyFileMarker ? "" : result.content;
+        const fileExists = await pathExists(outputFile);
+        if (fileExists) {
+          const existingContent = await readTextFile(outputFile);
+          conflicts.push({
+            outputPath: outputFile,
+            sourcePath: templateFile,
+            newContent: content,
+            existingContent
+          });
+        }
+        filesToProcess.push({
+          templateFile,
+          outputFile,
+          content,
+          isNew: !fileExists
+        });
+      }
+      let resolution = {
+        overwrite: [],
+        skip: [],
+        equal: []
+      };
+      if (conflicts.length > 0) {
+        resolution = await conflictResolver.resolveBatch(conflicts, force, dryRun);
+      }
+      for (const file of filesToProcess) {
+        if (file.isNew) {
+          if (!dryRun) {
+            await writeTextFile(file.outputFile, file.content);
+          }
+          actions.push({
+            type: "create",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+          created++;
+          logger.fileAction({
+            type: "create",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+        } else if (resolution.overwrite.includes(file.outputFile)) {
+          if (!dryRun) {
+            await writeTextFile(file.outputFile, file.content);
+          }
+          actions.push({
+            type: "overwrite",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+          overwritten++;
+          logger.fileAction({
+            type: "overwrite",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+        } else if (resolution.equal.includes(file.outputFile)) {
+          actions.push({
+            type: "skip-equal",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+          skippedEqual++;
+          logger.fileAction({
+            type: "skip-equal",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+        } else if (resolution.skip.includes(file.outputFile)) {
+          actions.push({
+            type: "skip-user",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+          skippedUser++;
+          logger.fileAction({
+            type: "skip-user",
+            sourcePath: file.templateFile,
+            outputPath: file.outputFile
+          });
+        }
+      }
+      const deleteEntries = await loadDeleteList(templatePath);
+      if (deleteEntries.length > 0) {
+        const deleteList = resolveDeleteList(deleteEntries, features);
+        const generatedOutputPaths = new Set(filesToProcess.map((f) => f.outputFile));
+        const deleteCandidates = [];
+        for (const relPath of deleteList) {
+          const absPath = join3(outputPath, relPath);
+          if (generatedOutputPaths.has(absPath)) {
+            logger.warn(
+              `Delete list entry '${relPath}' conflicts with generated file \u2014 skipping deletion`
+            );
+            continue;
+          }
+          if (await pathExists(absPath)) {
+            deleteCandidates.push(absPath);
+          }
+        }
+        if (deleteCandidates.length > 0) {
+          if (!enableDelete) {
+            for (const absPath of deleteCandidates) {
+              logger.warn(
+                `Would delete (pass --delete to enable): ${relative(outputPath, absPath)}`
+              );
+            }
+          } else {
+            const confirmed = await deleteResolver.resolveDeletes(deleteCandidates, force, dryRun);
+            for (const absPath of confirmed) {
+              if (!dryRun) {
+                await deleteFile(absPath);
+              }
+              actions.push({ type: "delete", outputPath: absPath });
+              deleted++;
+              logger.fileAction({ type: "delete", outputPath: absPath });
+            }
+          }
+        }
+      }
+      return {
+        actions,
+        created,
+        overwritten,
+        deleted,
+        skipped: skippedEmpty + skippedUser + skippedEqual,
+        skippedEmpty,
+        skippedUser,
+        skippedEqual
+      };
+    } catch (error) {
+      if (error instanceof Error && "code" in error) {
+        const code = error.code;
+        if (code === "EACCES" || code === "EPERM") {
+          throw new GenerationError(`Permission denied: ${error.message}`, "PERMISSION_DENIED");
+        }
+        if (code === "ENOSPC") {
+          throw new GenerationError(`Disk full: ${error.message}`, "DISK_FULL");
+        }
+      }
+      throw error;
+    }
+  }
+  // @awa-impl: GEN-8_AC-1, GEN-8_AC-2, GEN-8_AC-3
+  // @awa-impl: TPL-9_AC-1, TPL-9_AC-2
+  async *walkTemplates(dir) {
+    yield* walkDirectory(dir);
+  }
+  // @awa-impl: GEN-1_AC-1, GEN-1_AC-2, GEN-1_AC-3
+  computeOutputPath(templatePath, templateRoot, outputRoot) {
+    const relativePath = relative(templateRoot, templatePath);
+    return join3(outputRoot, relativePath);
+  }
+};
+var fileGenerator = new FileGenerator();
+
+// src/core/differ.ts
+var DiffEngine = class {
+  // @awa-impl: DIFF-1_AC-1, DIFF-1_AC-2, DIFF-1_AC-3
+  // @awa-impl: DIFF-2_AC-1, DIFF-2_AC-2, DIFF-2_AC-3, DIFF-2_AC-4, DIFF-2_AC-5
+  // @awa-impl: DIFF-3_AC-1, DIFF-3_AC-2, DIFF-3_AC-3
+  // @awa-impl: DIFF-4_AC-1, DIFF-4_AC-2
+  // @awa-impl: DIFF-5_AC-1, DIFF-5_AC-2, DIFF-5_AC-3
+  // @awa-impl: DIFF-6_AC-1, DIFF-6_AC-2, DIFF-6_AC-3
+  async diff(options) {
+    const { templatePath, targetPath, features, listUnknown } = options;
+    const tempPath = await this.createTempDir();
+    try {
+      const generateOptions = {
+        templatePath,
+        outputPath: tempPath,
+        features,
+        force: true,
+        dryRun: false,
+        delete: false
+      };
+      await fileGenerator.generate(generateOptions);
+      const generatedFiles = /* @__PURE__ */ new Set();
+      const targetFiles = /* @__PURE__ */ new Set();
+      if (await pathExists(tempPath)) {
+        for await (const file of walkDirectory(tempPath)) {
+          const relPath = relative2(tempPath, file);
+          generatedFiles.add(relPath);
+        }
+      }
+      if (await pathExists(targetPath)) {
+        for await (const file of walkDirectory(targetPath)) {
+          const relPath = relative2(targetPath, file);
+          targetFiles.add(relPath);
+        }
+      }
+      const files = [];
+      for (const relPath of generatedFiles) {
+        const generatedFilePath = join4(tempPath, relPath);
+        const targetFilePath = join4(targetPath, relPath);
+        if (targetFiles.has(relPath)) {
+          const fileDiff = await this.compareFiles(generatedFilePath, targetFilePath, relPath);
+          files.push(fileDiff);
+        } else {
+          files.push({
+            relativePath: relPath,
+            status: "new"
+          });
+        }
+      }
+      if (listUnknown) {
+        for (const relPath of targetFiles) {
+          if (generatedFiles.has(relPath)) {
+            continue;
+          }
+          files.push({
+            relativePath: relPath,
+            status: "extra"
+          });
+        }
+      }
+      const deleteEntries = await loadDeleteList(templatePath);
+      const deleteList = resolveDeleteList(deleteEntries, features ?? []);
+      for (const relPath of deleteList) {
+        if (targetFiles.has(relPath) && !generatedFiles.has(relPath)) {
+          const existingIdx = files.findIndex(
+            (f) => f.relativePath === relPath && f.status === "extra"
+          );
+          if (existingIdx !== -1) {
+            files.splice(existingIdx, 1);
+          }
+          files.push({
+            relativePath: relPath,
+            status: "delete-listed"
+          });
+        }
+      }
+      const identical = files.filter((f) => f.status === "identical").length;
+      const modified = files.filter((f) => f.status === "modified").length;
+      const newFiles = files.filter((f) => f.status === "new").length;
+      const extraFiles = files.filter((f) => f.status === "extra").length;
+      const binaryDiffers = files.filter((f) => f.status === "binary-differs").length;
+      const deleteListed = files.filter((f) => f.status === "delete-listed").length;
+      const hasDifferences = modified > 0 || newFiles > 0 || extraFiles > 0 || binaryDiffers > 0 || deleteListed > 0;
+      return {
+        files,
+        identical,
+        modified,
+        newFiles,
+        extraFiles,
+        binaryDiffers,
+        deleteListed,
+        hasDifferences
+      };
+    } finally {
+      await this.cleanupTempDir(tempPath);
+    }
+  }
+  // @awa-impl: DIFF-1_AC-1, DIFF-1_AC-2
+  async createTempDir() {
+    const systemTemp = tmpdir();
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    const tempPath = join4(systemTemp, `awa-diff-${timestamp}-${random}`);
+    await ensureDir(tempPath);
+    return tempPath;
+  }
+  // @awa-impl: DIFF-6_AC-1, DIFF-6_AC-2, DIFF-6_AC-3
+  async cleanupTempDir(tempPath) {
+    try {
+      if (await pathExists(tempPath)) {
+        await rmDir(tempPath);
+      }
+    } catch (_error) {
+    }
+  }
+  // @awa-impl: DIFF-2_AC-1, DIFF-2_AC-2, DIFF-2_AC-3, DIFF-2_AC-4, DIFF-2_AC-5
+  async compareFiles(generatedPath, targetPath, relativePath) {
+    const generatedBytes = await readBinaryFile(generatedPath);
+    const targetBytes = await readBinaryFile(targetPath);
+    if (generatedBytes.equals(targetBytes)) {
+      return {
+        relativePath,
+        status: "identical"
+      };
+    }
+    const isBinaryGenerated = await this.isBinaryFile(generatedPath);
+    const isBinaryTarget = await this.isBinaryFile(targetPath);
+    if (isBinaryGenerated || isBinaryTarget) {
+      return {
+        relativePath,
+        status: "binary-differs"
+      };
+    }
+    const generatedContent = generatedBytes.toString("utf-8");
+    const targetContent = targetBytes.toString("utf-8");
+    const patch = structuredPatch(
+      `a/${relativePath}`,
+      `b/${relativePath}`,
+      targetContent,
+      generatedContent,
+      "target",
+      "generated",
+      {
+        context: 3
+      }
+    );
+    const headerLines = [
+      `diff --git a/${relativePath} b/${relativePath}`,
+      `--- a/${relativePath}`,
+      `+++ b/${relativePath}`
+    ];
+    const hunkLines = patch.hunks.flatMap((hunk) => {
+      const lines = [`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`];
+      lines.push(...hunk.lines);
+      return lines;
+    });
+    const unifiedDiff = [...headerLines, ...hunkLines].join("\n");
+    return {
+      relativePath,
+      status: "modified",
+      unifiedDiff
+    };
+  }
+  // @awa-impl: DIFF-2_AC-5
+  async isBinaryFile(filePath) {
+    try {
+      return await detectBinaryFile(filePath);
+    } catch {
+      return false;
+    }
+  }
+};
+var diffEngine = new DiffEngine();
+
+// src/core/feature-resolver.ts
+var FeatureResolver = class {
+  validatePresets(presetNames, definitions) {
+    for (const name of presetNames) {
+      if (!definitions[name]) {
+        throw new ConfigError(`Unknown preset: ${name}`, "UNKNOWN_PRESET");
+      }
+    }
+  }
+  resolve(input) {
+    const { baseFeatures, presetNames, removeFeatures, presetDefinitions } = input;
+    this.validatePresets(presetNames, presetDefinitions);
+    const finalFeatures = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (feature) => {
+      if (seen.has(feature)) return;
+      seen.add(feature);
+      finalFeatures.push(feature);
+    };
+    for (const feature of baseFeatures) add(feature);
+    for (const presetName of presetNames) {
+      for (const feature of presetDefinitions[presetName] ?? []) add(feature);
+    }
+    if (removeFeatures.length === 0) return finalFeatures;
+    const removeSet = new Set(removeFeatures);
+    return finalFeatures.filter((f) => !removeSet.has(f));
+  }
+};
+var featureResolver = new FeatureResolver();
+
+// src/core/template-resolver.ts
+import { createHash } from "crypto";
+import { rm as rm2 } from "fs/promises";
+import { isAbsolute, join as join5, resolve } from "path";
+import degit from "degit";
+var TemplateResolver = class {
+  // @awa-impl: CLI-3_AC-2, TPL-10_AC-1
+  async resolve(source, refresh) {
+    if (!source) {
+      const bundledPath = join5(getTemplateDir(), "awa");
+      return {
+        type: "bundled",
+        localPath: bundledPath,
+        source: "bundled"
+      };
+    }
+    const type = this.detectType(source);
+    if (type === "local") {
+      const localPath = isAbsolute(source) ? source : resolve(process.cwd(), source);
+      if (!await pathExists(localPath)) {
+        throw new TemplateError(
+          `Template source not found: ${localPath}`,
+          "SOURCE_NOT_FOUND",
+          source
+        );
+      }
+      return {
+        type: "local",
+        localPath,
+        source
+      };
+    }
+    if (type === "git") {
+      const cachePath = this.getCachePath(source);
+      const cacheExists = await pathExists(cachePath);
+      if (cacheExists && !refresh) {
+        logger.info(`Using cached template: ${source}`);
+        return {
+          type: "git",
+          localPath: cachePath,
+          source
+        };
+      }
+      try {
+        if (cacheExists && refresh) {
+          logger.info(`Refreshing template: ${source}`);
+          await rm2(cachePath, { recursive: true, force: true });
+        } else {
+          logger.info(`Fetching template: ${source}`);
+        }
+        await ensureDir(cachePath);
+        const emitter = degit(source, { cache: false, force: true });
+        await emitter.clone(cachePath);
+        return {
+          type: "git",
+          localPath: cachePath,
+          source
+        };
+      } catch (error) {
+        throw new TemplateError(
+          `Failed to fetch Git template: ${error instanceof Error ? error.message : String(error)}`,
+          "FETCH_FAILED",
+          source
+        );
+      }
+    }
+    throw new TemplateError(
+      `Unable to resolve template source: ${source}`,
+      "SOURCE_NOT_FOUND",
+      source
+    );
+  }
+  // @awa-impl: TPL-2_AC-1 through TPL-2_AC-6
+  detectType(source) {
+    if (source.startsWith(".") || source.startsWith("/") || source.startsWith("~")) {
+      return "local";
+    }
+    if (/^[a-zA-Z]:/.test(source)) {
+      return "local";
+    }
+    return "git";
+  }
+  // @awa-impl: TPL-3_AC-1
+  getCachePath(source) {
+    const hash = createHash("sha256").update(source).digest("hex").substring(0, 16);
+    const cacheDir = getCacheDir();
+    return join5(cacheDir, hash);
+  }
+};
+var templateResolver = new TemplateResolver();
+
+// src/commands/diff.ts
+async function diffCommand(cliOptions) {
+  try {
+    intro("awa CLI - Template Diff");
+    const fileConfig = await configLoader.load(cliOptions.config ?? null);
+    const options = configLoader.merge(cliOptions, fileConfig);
+    if (!await pathExists(options.output)) {
+      throw new DiffError(`Target directory does not exist: ${options.output}`);
+    }
+    const targetPath = options.output;
+    const template = await templateResolver.resolve(options.template, options.refresh);
+    const features = featureResolver.resolve({
+      baseFeatures: [...options.features],
+      presetNames: [...options.preset],
+      removeFeatures: [...options.removeFeatures],
+      presetDefinitions: options.presets
+    });
+    const result = await diffEngine.diff({
+      templatePath: template.localPath,
+      targetPath,
+      features,
+      listUnknown: options.listUnknown
+    });
+    for (const file of result.files) {
+      switch (file.status) {
+        case "modified":
+          logger.info(`Modified: ${file.relativePath}`);
+          if (file.unifiedDiff) {
+            const lines = file.unifiedDiff.split("\n");
+            for (const line of lines) {
+              if (line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ")) {
+                logger.diffLine(line, "context");
+              } else if (line.startsWith("+")) {
+                logger.diffLine(line, "add");
+              } else if (line.startsWith("-")) {
+                logger.diffLine(line, "remove");
+              } else if (line.startsWith("@@")) {
+                logger.diffLine(line, "context");
+              } else {
+                logger.diffLine(line, "context");
+              }
+            }
+          }
+          break;
+        case "new":
+          logger.info(`New file: ${file.relativePath}`);
+          break;
+        case "extra":
+          logger.warn(`Extra file (not in template): ${file.relativePath}`);
+          break;
+        case "binary-differs":
+          logger.warn(`binary files differ: ${file.relativePath}`);
+          break;
+        case "delete-listed":
+          logger.warn(`Delete listed: ${file.relativePath}`);
+          break;
+        case "identical":
+          break;
+      }
+    }
+    logger.diffSummary(result);
+    outro("Diff complete!");
+    return result.hasDifferences ? 1 : 0;
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    return 2;
+  }
+}
+
+// src/commands/generate.ts
+import { intro as intro2, isCancel as isCancel2, multiselect as multiselect2, outro as outro2 } from "@clack/prompts";
+var TOOL_FEATURES = [
+  { value: "copilot", label: "GitHub Copilot" },
+  { value: "claude", label: "Claude Code" },
+  { value: "cursor", label: "Cursor" },
+  { value: "windsurf", label: "Windsurf" },
+  { value: "kilocode", label: "Kilocode" },
+  { value: "opencode", label: "OpenCode" },
+  { value: "gemini", label: "Gemini CLI" },
+  { value: "roo", label: "Roo Code" },
+  { value: "qwen", label: "Qwen Code" },
+  { value: "codex", label: "Codex CLI" },
+  { value: "agy", label: "Antigravity (agy)" },
+  { value: "agents-md", label: "AGENTS.md (cross-tool)" }
+];
+var TOOL_FEATURE_VALUES = new Set(TOOL_FEATURES.map((t) => t.value));
+async function generateCommand(cliOptions) {
+  try {
+    intro2("awa CLI - Template Generator");
+    const fileConfig = await configLoader.load(cliOptions.config ?? null);
+    const options = configLoader.merge(cliOptions, fileConfig);
+    const template = await templateResolver.resolve(options.template, options.refresh);
+    const features = featureResolver.resolve({
+      baseFeatures: [...options.features],
+      presetNames: [...options.preset],
+      removeFeatures: [...options.removeFeatures],
+      presetDefinitions: options.presets
+    });
+    const hasToolFlag = features.some((f) => TOOL_FEATURE_VALUES.has(f));
+    if (!hasToolFlag) {
+      const selected = await multiselect2({
+        message: "Select AI tools to generate for (space to toggle, enter to confirm):",
+        options: TOOL_FEATURES.map((t) => ({ value: t.value, label: t.label })),
+        required: true
+      });
+      if (isCancel2(selected)) {
+        logger.info("Generation cancelled.");
+        process.exit(0);
+      }
+      features.push(...selected);
+    }
+    if (options.dryRun) {
+      logger.info("Running in dry-run mode (no files will be modified)");
+    }
+    if (options.force) {
+      logger.info("Force mode enabled (existing files will be overwritten)");
+    }
+    const result = await fileGenerator.generate({
+      templatePath: template.localPath,
+      outputPath: options.output,
+      features,
+      force: options.force,
+      dryRun: options.dryRun,
+      delete: options.delete
+    });
+    logger.summary(result);
+    outro2("Generation complete!");
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error(String(error));
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var version = PACKAGE_INFO.version;
+var program = new Command();
+program.name("awa").description("awa - tool for generating AI coding agent configuration files").version(version, "-v, --version", "Display version number");
+program.command("generate").description("Generate AI agent configuration files from templates").argument("[output]", "Output directory (optional if specified in config)").option("-t, --template <source>", "Template source (local path or Git repository)").option("-f, --features <flag...>", "Feature flags (can be specified multiple times)").option("--preset <name...>", "Preset names to enable (can be specified multiple times)").option(
+  "--remove-features <flag...>",
+  "Feature flags to remove (can be specified multiple times)"
+).option("--force", "Force overwrite existing files without prompting", false).option("--dry-run", "Preview changes without modifying files", false).option(
+  "--delete",
+  "Enable deletion of files listed in the delete list (default: warn only)",
+  false
+).option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).action(async (output, options) => {
+  const cliOptions = {
+    output,
+    template: options.template,
+    features: options.features || [],
+    preset: options.preset || [],
+    removeFeatures: options.removeFeatures || [],
+    force: options.force,
+    dryRun: options.dryRun,
+    delete: options.delete,
+    config: options.config,
+    refresh: options.refresh
+  };
+  await generateCommand(cliOptions);
+});
+program.command("diff").description("Compare template output with existing target directory").argument("[target]", "Target directory to compare against (optional if specified in config)").option("-t, --template <source>", "Template source (local path or Git repository)").option("-f, --features <flag...>", "Feature flags (can be specified multiple times)").option("--preset <name...>", "Preset names to enable (can be specified multiple times)").option(
+  "--remove-features <flag...>",
+  "Feature flags to remove (can be specified multiple times)"
+).option("-c, --config <path>", "Path to configuration file").option("--refresh", "Force refresh of cached Git templates", false).option("--list-unknown", "Include target-only files in diff results", false).action(async (target, options) => {
+  const cliOptions = {
+    output: target,
+    // Use target as output for consistency
+    template: options.template,
+    features: options.features || [],
+    preset: options.preset || [],
+    removeFeatures: options.removeFeatures || [],
+    config: options.config,
+    refresh: options.refresh,
+    listUnknown: options.listUnknown
+  };
+  const exitCode = await diffCommand(cliOptions);
+  process.exit(exitCode);
+});
+program.parse();
+//# sourceMappingURL=index.js.map