@ncoderz/awa 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import {
+  ConfigError,
+  DiffError,
+  GenerationError,
+  TemplateError,
+  configLoader,
+  deleteFile,
+  ensureDir,
+  getCacheDir,
+  getTemplateDir,
+  logger,
+  pathExists,
+  readBinaryFile,
+  readTextFile,
+  rmDir,
+  walkDirectory,
+  writeTextFile
+} from "./chunk-3SSUJFKN.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -6,7 +24,7 @@ import { Command } from "commander";
 // src/_generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@ncoderz/awa",
-  "version": "1.1.0",
+  "version": "1.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."
@@ -110,7 +128,7 @@ var IGNORE_LINE_RE = /@awa-ignore\b/;
 var IGNORE_START_RE = /@awa-ignore-start\b/;
 var IGNORE_END_RE = /@awa-ignore-end\b/;
 async function scanMarkers(config) {
-  const files = await collectCodeFiles(config.codeGlobs, config.ignore);
+  const files = await collectCodeFiles(config.codeGlobs, config.codeIgnore);
   const markers = [];
   const findings = [];
   for (const filePath of files) {
@@ -992,7 +1010,7 @@ function collectAllCodeBlocks(section) {
 import { readFile as readFile4 } from "fs/promises";
 import { basename } from "path";
 async function parseSpecs(config) {
-  const files = await collectSpecFiles(config.specGlobs, config.ignore);
+  const files = await collectSpecFiles(config.specGlobs, config.specIgnore);
   const specFiles = [];
   const requirementIds = /* @__PURE__ */ new Set();
   const acIds = /* @__PURE__ */ new Set();
@@ -1156,9 +1174,30 @@ function checkSpecAgainstSpec(specs, markers, config) {
 
 // src/core/check/types.ts
 var DEFAULT_CHECK_CONFIG = {
-  specGlobs: [".awa/specs/**/*.md"],
-  codeGlobs: ["src/**/*.{ts,js,tsx,jsx,py,go,rs,java,cs}"],
-  ignore: ["node_modules/**", "dist/**"],
+  specGlobs: [
+    ".awa/specs/ARCHITECTURE.md",
+    ".awa/specs/FEAT-*.md",
+    ".awa/specs/REQ-*.md",
+    ".awa/specs/DESIGN-*.md",
+    ".awa/specs/EXAMPLES-*.md",
+    ".awa/specs/API-*.tsp",
+    ".awa/tasks/TASK-*.md",
+    ".awa/plans/PLAN-*.md",
+    ".awa/align/ALIGN-*.md"
+  ],
+  codeGlobs: [
+    "**/*.{ts,js,tsx,jsx,mts,mjs,cjs,py,go,rs,java,kt,kts,cs,c,h,cpp,cc,cxx,hpp,hxx,swift,rb,php,scala,ex,exs,dart,lua,zig}"
+  ],
+  specIgnore: [],
+  codeIgnore: [
+    "node_modules/**",
+    "dist/**",
+    "vendor/**",
+    "target/**",
+    "build/**",
+    "out/**",
+    ".awa/**"
+  ],
   ignoreMarkers: [],
   markers: ["@awa-impl", "@awa-test", "@awa-component"],
   idPattern: "([A-Z][A-Z0-9]*-\\d+(?:\\.\\d+)?(?:_AC-\\d+)?|[A-Z][A-Z0-9]*_P-\\d+)",
@@ -1170,576 +1209,6 @@ var DEFAULT_CHECK_CONFIG = {
   specOnly: false
 };
 
-// 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 as readFile5, rm, stat, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join as join2 } 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 readFile5(path, "utf-8");
-}
-async function readBinaryFile(path) {
-  return readFile5(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 = join2(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 join2(homedir(), ".cache", "awa", "templates");
-}
-function getTemplateDir() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-  if (currentDir.includes("/dist")) {
-    return join2(dirname(currentDir), "templates");
-  }
-  return join2(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 chalk2 from "chalk";
-var Logger = class {
-  info(message) {
-    console.log(chalk2.blue("\u2139"), message);
-  }
-  success(message) {
-    console.log(chalk2.green("\u2714"), message);
-  }
-  warn(message) {
-    console.warn(chalk2.yellow("\u26A0"), message);
-  }
-  error(message) {
-    console.error(chalk2.red("\u2716"), message);
-  }
-  fileAction(action) {
-    const { type, outputPath } = action;
-    switch (type) {
-      case "create":
-        console.log(chalk2.green("  + "), chalk2.dim(outputPath));
-        break;
-      case "overwrite":
-        console.log(chalk2.yellow("  ~ "), chalk2.dim(outputPath));
-        break;
-      case "skip-user":
-        console.log(chalk2.blue("  - "), chalk2.dim(outputPath), chalk2.dim("(skipped)"));
-        break;
-      case "skip-empty":
-        console.log(chalk2.dim("  \xB7 "), chalk2.dim(outputPath), chalk2.dim("(empty)"));
-        break;
-      case "skip-equal":
-        console.log(chalk2.dim("  = "), chalk2.dim(outputPath), chalk2.dim("(unchanged)"));
-        break;
-      case "delete":
-        console.log(chalk2.red("  \u2716 "), chalk2.dim(outputPath), chalk2.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(chalk2.bold("Summary:"));
-    if (result.created === 0 && result.overwritten === 0 && result.deleted === 0) {
-      console.log(chalk2.yellow("  \u26A0 No files were created, overwritten, or deleted"));
-    }
-    if (result.created > 0) {
-      console.log(chalk2.green(`  Created: ${result.created}`));
-    }
-    if (result.overwritten > 0) {
-      console.log(chalk2.yellow(`  Overwritten: ${result.overwritten}`));
-    }
-    if (result.deleted > 0) {
-      console.log(chalk2.red(`  Deleted: ${result.deleted}`));
-    }
-    if (result.skippedEqual > 0) {
-      console.log(chalk2.dim(`  Skipped (equal): ${result.skippedEqual}`));
-    }
-    if (result.skippedUser > 0) {
-      console.log(chalk2.blue(`  Skipped (user): ${result.skippedUser}`));
-    }
-    if (result.skippedEmpty > 0) {
-      console.log(chalk2.dim(`  Skipped (empty): ${result.skippedEmpty}`));
-    }
-    console.log("");
-  }
-  // @awa-impl: DIFF-4_AC-3
-  diffLine(line, type) {
-    switch (type) {
-      case "add":
-        console.log(chalk2.green(line));
-        break;
-      case "remove":
-        console.log(chalk2.red(line));
-        break;
-      case "context":
-        console.log(chalk2.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(chalk2.bold(`${filesCompared} files compared, ${differences} differences`));
-    if (!result.hasDifferences) {
-      console.log(chalk2.green("\u2714 No differences found"));
-    }
-    console.log(chalk2.bold("Summary:"));
-    console.log(chalk2.dim(`  Identical: ${result.identical}`));
-    if (result.modified > 0) {
-      console.log(chalk2.yellow(`  Modified: ${result.modified}`));
-    }
-    if (result.newFiles > 0) {
-      console.log(chalk2.green(`  New: ${result.newFiles}`));
-    }
-    if (result.extraFiles > 0) {
-      console.log(chalk2.red(`  Extra: ${result.extraFiles}`));
-    }
-    if (result.binaryDiffers > 0) {
-      console.log(chalk2.red(`  Binary differs: ${result.binaryDiffers}`));
-    }
-    if (result.deleteListed > 0) {
-      console.log(chalk2.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.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"
-      ]);
-      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();
-
 // src/commands/check.ts
 async function checkCommand(cliOptions) {
   try {
@@ -1787,9 +1256,14 @@ function buildCheckConfig(fileConfig, cliOptions) {
     ...DEFAULT_CHECK_CONFIG.crossRefPatterns
   ];
   const idPattern = typeof section?.["id-pattern"] === "string" ? section["id-pattern"] : DEFAULT_CHECK_CONFIG.idPattern;
-  const configIgnore = toStringArray(section?.ignore) ?? [...DEFAULT_CHECK_CONFIG.ignore];
-  const cliIgnore = cliOptions.ignore ?? [];
-  const ignore = [...configIgnore, ...cliIgnore];
+  const configSpecIgnore = toStringArray(section?.["spec-ignore"]) ?? [
+    ...DEFAULT_CHECK_CONFIG.specIgnore
+  ];
+  const configCodeIgnore = toStringArray(section?.["code-ignore"]) ?? [
+    ...DEFAULT_CHECK_CONFIG.codeIgnore
+  ];
+  const specIgnore = [...configSpecIgnore, ...cliOptions.specIgnore ?? []];
+  const codeIgnore = [...configCodeIgnore, ...cliOptions.codeIgnore ?? []];
   const ignoreMarkers = toStringArray(section?.["ignore-markers"]) ?? [
     ...DEFAULT_CHECK_CONFIG.ignoreMarkers
   ];
@@ -1801,7 +1275,8 @@ function buildCheckConfig(fileConfig, cliOptions) {
   return {
     specGlobs,
     codeGlobs,
-    ignore,
+    specIgnore,
+    codeIgnore,
     ignoreMarkers,
     markers,
     idPattern,
@@ -1882,12 +1357,12 @@ var batchRunner = new BatchRunner();
 
 // src/core/differ.ts
 import { tmpdir } from "os";
-import { join as join5, relative as relative2 } from "path";
+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 join3 } from "path";
+import { join as join2 } from "path";
 var DELETE_LIST_FILENAME = "_delete.txt";
 function parseDeleteList(content) {
   const entries = [];
@@ -1914,7 +1389,7 @@ function resolveDeleteList(entries, 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 = join3(templatePath, DELETE_LIST_FILENAME);
+  const deleteListPath = join2(templatePath, DELETE_LIST_FILENAME);
   if (!await pathExists(deleteListPath)) {
     return [];
   }
@@ -1923,12 +1398,12 @@ async function loadDeleteList(templatePath) {
 }
 
 // src/core/generator.ts
-import { join as join4, relative } from "path";
+import { join as join3, relative } from "path";
 
 // src/core/resolver.ts
 import { MultiSelectPrompt } from "@clack/core";
 import { isCancel, multiselect } from "@clack/prompts";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 var _unicode = process.platform !== "win32";
 var _s = (c, fb) => _unicode ? c : fb;
 var _CHECKED = _s("\u25FC", "[+]");
@@ -1938,20 +1413,20 @@ var _BAR = _s("\u2502", "|");
 var _BAR_END = _s("\u2514", "-");
 function _renderDeleteItem(opt, state) {
   const label = opt.label ?? opt.value;
-  const hint = opt.hint ? ` ${chalk3.dim(`(${opt.hint})`)}` : "";
+  const hint = opt.hint ? ` ${chalk2.dim(`(${opt.hint})`)}` : "";
   switch (state) {
     case "active":
-      return `${chalk3.cyan(_UNCHECKED_A)} ${label}${hint}`;
+      return `${chalk2.cyan(_UNCHECKED_A)} ${label}${hint}`;
     case "selected":
-      return `${chalk3.red(_CHECKED)} ${chalk3.dim(label)}${hint}`;
+      return `${chalk2.red(_CHECKED)} ${chalk2.dim(label)}${hint}`;
     case "active-selected":
-      return `${chalk3.red(_CHECKED)} ${label}${hint}`;
+      return `${chalk2.red(_CHECKED)} ${label}${hint}`;
     case "cancelled":
-      return chalk3.strikethrough(chalk3.dim(label));
+      return chalk2.strikethrough(chalk2.dim(label));
     case "submitted":
-      return chalk3.dim(label);
+      return chalk2.dim(label);
     default:
-      return `${chalk3.dim(_UNCHECKED)} ${chalk3.dim(label)}`;
+      return `${chalk2.dim(_UNCHECKED)} ${chalk2.dim(label)}`;
   }
 }
 async function deleteMultiselect(opts) {
@@ -1962,8 +1437,8 @@ async function deleteMultiselect(opts) {
     required,
     render() {
       const self = this;
-      const header = `${chalk3.gray(_BAR)}
-${chalk3.cyan(_BAR)}  ${message}
+      const header = `${chalk2.gray(_BAR)}
+${chalk2.cyan(_BAR)}  ${message}
 `;
       const getState = (opt, idx) => {
         const active = idx === self.cursor;
@@ -1975,16 +1450,16 @@ ${chalk3.cyan(_BAR)}  ${message}
       };
       switch (self.state) {
         case "submit":
-          return `${header}${chalk3.gray(_BAR)}  ` + (self.options.filter((o) => self.value.includes(o.value)).map((o) => _renderDeleteItem(o, "submitted")).join(chalk3.dim(", ")) || chalk3.dim("none"));
+          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(chalk3.dim(", "));
-          return `${header}${chalk3.gray(_BAR)}  ${cancelled.trim() ? `${cancelled}
-${chalk3.gray(_BAR)}` : chalk3.dim("none")}`;
+          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}${chalk3.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
-${chalk3.cyan(_BAR)}  `) + `
-${chalk3.cyan(_BAR_END)}
+          return `${header}${chalk2.cyan(_BAR)}  ` + self.options.map((o, i) => _renderDeleteItem(o, getState(o, i))).join(`
+${chalk2.cyan(_BAR)}  `) + `
+${chalk2.cyan(_BAR_END)}
 `;
       }
     }
@@ -2254,7 +1729,7 @@ var FileGenerator = class {
         const generatedOutputPaths = new Set(filesToProcess.map((f) => f.outputFile));
         const deleteCandidates = [];
         for (const relPath of deleteList) {
-          const absPath = join4(outputPath, relPath);
+          const absPath = join3(outputPath, relPath);
           if (generatedOutputPaths.has(absPath)) {
             logger.warn(
               `Delete list entry '${relPath}' conflicts with generated file \u2014 skipping deletion`
@@ -2316,7 +1791,7 @@ var FileGenerator = class {
   // @awa-impl: GEN-1_AC-1, GEN-1_AC-2, GEN-1_AC-3
   computeOutputPath(templatePath, templateRoot, outputRoot) {
     const relativePath = relative(templateRoot, templatePath);
-    return join4(outputRoot, relativePath);
+    return join3(outputRoot, relativePath);
   }
 };
 var fileGenerator = new FileGenerator();
@@ -2358,8 +1833,8 @@ var DiffEngine = class {
       }
       const files = [];
       for (const relPath of generatedFiles) {
-        const generatedFilePath = join5(tempPath, relPath);
-        const targetFilePath = join5(targetPath, relPath);
+        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);
@@ -2423,7 +1898,7 @@ var DiffEngine = class {
     const systemTemp = tmpdir();
     const timestamp = Date.now();
     const random = Math.random().toString(36).substring(2, 8);
-    const tempPath = join5(systemTemp, `awa-diff-${timestamp}-${random}`);
+    const tempPath = join4(systemTemp, `awa-diff-${timestamp}-${random}`);
     await ensureDir(tempPath);
     return tempPath;
   }
@@ -2576,18 +2051,18 @@ function writeJsonOutput(data) {
 // src/core/overlay.ts
 import { cp } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 
 // src/core/template-resolver.ts
 import { createHash } from "crypto";
-import { rm as rm2 } from "fs/promises";
-import { isAbsolute, join as join6, resolve } from "path";
+import { rm } 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 = join6(getTemplateDir(), "awa");
+      const bundledPath = join5(getTemplateDir(), "awa");
       return {
         type: "bundled",
         localPath: bundledPath,
@@ -2624,7 +2099,7 @@ var TemplateResolver = class {
       try {
         if (cacheExists && refresh) {
           logger.info(`Refreshing template: ${source}`);
-          await rm2(cachePath, { recursive: true, force: true });
+          await rm(cachePath, { recursive: true, force: true });
         } else {
           logger.info(`Fetching template: ${source}`);
         }
@@ -2664,7 +2139,7 @@ var TemplateResolver = class {
   getCachePath(source) {
     const hash = createHash("sha256").update(source).digest("hex").substring(0, 16);
     const cacheDir = getCacheDir();
-    return join6(cacheDir, hash);
+    return join5(cacheDir, hash);
   }
 };
 var templateResolver = new TemplateResolver();
@@ -2681,7 +2156,7 @@ async function resolveOverlays(overlays, refresh) {
 async function buildMergedDir(baseDir, overlayDirs) {
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 8);
-  const tempPath = join7(tmpdir2(), `awa-overlay-${timestamp}-${random}`);
+  const tempPath = join6(tmpdir2(), `awa-overlay-${timestamp}-${random}`);
   await ensureDir(tempPath);
   await cp(baseDir, tempPath, { recursive: true });
   for (const overlayDir of overlayDirs) {
@@ -2905,7 +2380,7 @@ async function diffCommand(cliOptions) {
 import { intro as intro2, outro as outro2 } from "@clack/prompts";
 
 // src/core/features/reporter.ts
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 var FeaturesReporter = class {
   // @awa-impl: DISC-6_AC-1, DISC-7_AC-1
   /** Render the features report to stdout. */
@@ -2940,25 +2415,25 @@ var FeaturesReporter = class {
   reportTable(scanResult, presets) {
     const { features, filesScanned } = scanResult;
     if (features.length === 0) {
-      console.log(chalk4.yellow("No feature flags found."));
-      console.log(chalk4.dim(`(${filesScanned} files scanned)`));
+      console.log(chalk3.yellow("No feature flags found."));
+      console.log(chalk3.dim(`(${filesScanned} files scanned)`));
       return;
     }
-    console.log(chalk4.bold(`Feature flags (${features.length} found):
+    console.log(chalk3.bold(`Feature flags (${features.length} found):
 `));
     for (const feature of features) {
-      console.log(`  ${chalk4.cyan(feature.name)}`);
+      console.log(`  ${chalk3.cyan(feature.name)}`);
       for (const file of feature.files) {
-        console.log(`    ${chalk4.dim(file)}`);
+        console.log(`    ${chalk3.dim(file)}`);
       }
     }
     console.log("");
-    console.log(chalk4.dim(`${filesScanned} files scanned`));
+    console.log(chalk3.dim(`${filesScanned} files scanned`));
     if (presets && Object.keys(presets).length > 0) {
       console.log("");
-      console.log(chalk4.bold("Presets (from .awa.toml):\n"));
+      console.log(chalk3.bold("Presets (from .awa.toml):\n"));
       for (const [name, flags] of Object.entries(presets)) {
-        console.log(`  ${chalk4.green(name)}: ${flags.join(", ")}`);
+        console.log(`  ${chalk3.green(name)}: ${flags.join(", ")}`);
       }
     }
   }
@@ -2966,13 +2441,13 @@ var FeaturesReporter = class {
 var featuresReporter = new FeaturesReporter();
 
 // src/core/features/scanner.ts
-import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
-import { join as join8, relative as relative3 } from "path";
+import { readdir, readFile as readFile5 } from "fs/promises";
+import { join as join7, relative as relative3 } from "path";
 var FEATURE_PATTERN = /it\.features\.(?:includes|indexOf)\(\s*['"]([^'"]+)['"]\s*\)/g;
 async function* walkAllFiles(dir) {
-  const entries = await readdir2(dir, { withFileTypes: true });
+  const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join8(dir, entry.name);
+    const fullPath = join7(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkAllFiles(fullPath);
     } else if (entry.isFile()) {
@@ -3000,7 +2475,7 @@ var FeatureScanner = class {
     for await (const filePath of walkAllFiles(templatePath)) {
       filesScanned++;
       try {
-        const content = await readFile6(filePath, "utf-8");
+        const content = await readFile5(filePath, "utf-8");
         const flags = this.extractFlags(content);
         const relPath = relative3(templatePath, filePath);
         for (const flag of flags) {
@@ -3176,21 +2651,21 @@ async function generateCommand(cliOptions) {
 import { intro as intro4, outro as outro4 } from "@clack/prompts";
 
 // src/core/template-test/fixture-loader.ts
-import { readdir as readdir3 } from "fs/promises";
-import { basename as basename2, extname, join as join9 } from "path";
-import { parse as parse2 } from "smol-toml";
+import { readdir as readdir2 } from "fs/promises";
+import { basename as basename2, extname, join as join8 } from "path";
+import { parse } from "smol-toml";
 async function discoverFixtures(templatePath) {
-  const testsDir = join9(templatePath, "_tests");
+  const testsDir = join8(templatePath, "_tests");
   let entries;
   try {
-    const dirEntries = await readdir3(testsDir, { withFileTypes: true });
+    const dirEntries = await readdir2(testsDir, { withFileTypes: true });
     entries = dirEntries.filter((e) => e.isFile() && extname(e.name) === ".toml").map((e) => e.name).sort();
   } catch {
     return [];
   }
   const fixtures = [];
   for (const filename of entries) {
-    const filePath = join9(testsDir, filename);
+    const filePath = join8(testsDir, filename);
     const fixture = await parseFixture(filePath);
     fixtures.push(fixture);
   }
@@ -3198,7 +2673,7 @@ async function discoverFixtures(templatePath) {
 }
 async function parseFixture(filePath) {
   const content = await readTextFile(filePath);
-  const parsed = parse2(content);
+  const parsed = parse(content);
   const name = basename2(filePath, extname(filePath));
   const features = toStringArray2(parsed.features) ?? [];
   const preset = toStringArray2(parsed.preset) ?? [];
@@ -3221,61 +2696,61 @@ function toStringArray2(value) {
 }
 
 // src/core/template-test/reporter.ts
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 function report2(result) {
   console.log("");
   for (const fixture of result.results) {
     reportFixture(fixture);
   }
   console.log("");
-  console.log(chalk5.bold("Test Summary:"));
+  console.log(chalk4.bold("Test Summary:"));
   console.log(`  Total:  ${result.total}`);
-  console.log(chalk5.green(`  Passed: ${result.passed}`));
+  console.log(chalk4.green(`  Passed: ${result.passed}`));
   if (result.failed > 0) {
-    console.log(chalk5.red(`  Failed: ${result.failed}`));
+    console.log(chalk4.red(`  Failed: ${result.failed}`));
   }
   console.log("");
 }
 function reportFixture(fixture) {
-  const icon = fixture.passed ? chalk5.green("\u2714") : chalk5.red("\u2716");
+  const icon = fixture.passed ? chalk4.green("\u2714") : chalk4.red("\u2716");
   console.log(`${icon} ${fixture.name}`);
   if (fixture.error) {
-    console.log(chalk5.red(`    Error: ${fixture.error}`));
+    console.log(chalk4.red(`    Error: ${fixture.error}`));
     return;
   }
   const missingFiles = fixture.fileResults.filter((r) => !r.found);
   for (const missing of missingFiles) {
-    console.log(chalk5.red(`    Missing file: ${missing.path}`));
+    console.log(chalk4.red(`    Missing file: ${missing.path}`));
   }
   const snapshotFailures = fixture.snapshotResults.filter((r) => r.status !== "match");
   for (const failure of snapshotFailures) {
     switch (failure.status) {
       case "mismatch":
-        console.log(chalk5.yellow(`    Snapshot mismatch: ${failure.path}`));
+        console.log(chalk4.yellow(`    Snapshot mismatch: ${failure.path}`));
         break;
       case "missing-snapshot":
-        console.log(chalk5.yellow(`    Missing snapshot: ${failure.path}`));
+        console.log(chalk4.yellow(`    Missing snapshot: ${failure.path}`));
         break;
       case "extra-snapshot":
-        console.log(chalk5.yellow(`    Extra snapshot (not in output): ${failure.path}`));
+        console.log(chalk4.yellow(`    Extra snapshot (not in output): ${failure.path}`));
         break;
     }
   }
 }
 
 // src/core/template-test/runner.ts
-import { mkdir as mkdir3, rm as rm4 } from "fs/promises";
+import { mkdir as mkdir2, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 
 // src/core/template-test/snapshot.ts
-import { mkdir as mkdir2, readdir as readdir4, rm as rm3 } from "fs/promises";
-import { join as join10, relative as relative4 } from "path";
+import { mkdir, readdir as readdir3, rm as rm2 } from "fs/promises";
+import { join as join9, relative as relative4 } from "path";
 async function walkRelative(dir, base) {
   const results = [];
-  const entries = await readdir4(dir, { withFileTypes: true });
+  const entries = await readdir3(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join10(dir, entry.name);
+    const fullPath = join9(dir, entry.name);
     if (entry.isDirectory()) {
       const sub = await walkRelative(fullPath, base);
       results.push(...sub);
@@ -3292,8 +2767,8 @@ async function compareSnapshots(renderedDir, snapshotDir) {
   const snapshotSet = new Set(snapshotFiles);
   const renderedSet = new Set(renderedFiles);
   for (const file of renderedFiles) {
-    const renderedPath = join10(renderedDir, file);
-    const snapshotPath = join10(snapshotDir, file);
+    const renderedPath = join9(renderedDir, file);
+    const snapshotPath = join9(snapshotDir, file);
     if (!snapshotSet.has(file)) {
       results.push({ path: file, status: "missing-snapshot" });
       continue;
@@ -3314,13 +2789,13 @@ async function compareSnapshots(renderedDir, snapshotDir) {
 }
 async function updateSnapshots(renderedDir, snapshotDir) {
   if (await pathExists(snapshotDir)) {
-    await rm3(snapshotDir, { recursive: true, force: true });
+    await rm2(snapshotDir, { recursive: true, force: true });
   }
-  await mkdir2(snapshotDir, { recursive: true });
+  await mkdir(snapshotDir, { recursive: true });
   const files = await walkRelative(renderedDir, renderedDir);
   for (const file of files) {
-    const srcPath = join10(renderedDir, file);
-    const destPath = join10(snapshotDir, file);
+    const srcPath = join9(renderedDir, file);
+    const destPath = join9(snapshotDir, file);
     const content = await readTextFile(srcPath);
     await writeTextFile(destPath, content);
   }
@@ -3328,9 +2803,9 @@ async function updateSnapshots(renderedDir, snapshotDir) {
 
 // src/core/template-test/runner.ts
 async function runFixture(fixture, templatePath, options, presetDefinitions = {}) {
-  const tempDir = join11(tmpdir3(), `awa-test-${fixture.name}-${Date.now()}`);
+  const tempDir = join10(tmpdir3(), `awa-test-${fixture.name}-${Date.now()}`);
   try {
-    await mkdir3(tempDir, { recursive: true });
+    await mkdir2(tempDir, { recursive: true });
     const features = featureResolver.resolve({
       baseFeatures: [...fixture.features],
       presetNames: [...fixture.preset],
@@ -3347,12 +2822,12 @@ async function runFixture(fixture, templatePath, options, presetDefinitions = {}
     });
     const fileResults = [];
     for (const expectedFile of fixture.expectedFiles) {
-      const fullPath = join11(tempDir, expectedFile);
+      const fullPath = join10(tempDir, expectedFile);
       const found = await pathExists(fullPath);
       fileResults.push({ path: expectedFile, found });
     }
     const missingFiles = fileResults.filter((r) => !r.found);
-    const snapshotDir = join11(templatePath, "_tests", fixture.name);
+    const snapshotDir = join10(templatePath, "_tests", fixture.name);
     let snapshotResults = [];
     if (options.updateSnapshots) {
       await updateSnapshots(tempDir, snapshotDir);
@@ -3376,7 +2851,7 @@ async function runFixture(fixture, templatePath, options, presetDefinitions = {}
       error: error instanceof Error ? error.message : String(error)
     };
   } finally {
-    await rm4(tempDir, { recursive: true, force: true }).catch(() => {
+    await rm3(tempDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -3434,6 +2909,91 @@ async function testCommand(options) {
   }
 }
 
+// src/utils/update-check.ts
+import chalk5 from "chalk";
+function compareSemver(a, b) {
+  const partsA = a.split(".").map((s) => Number.parseInt(s, 10));
+  const partsB = b.split(".").map((s) => Number.parseInt(s, 10));
+  for (let i = 0; i < 3; i++) {
+    const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function isMajorVersionBump(current, latest) {
+  const currentMajor = Number.parseInt(current.split(".")[0] ?? "0", 10);
+  const latestMajor = Number.parseInt(latest.split(".")[0] ?? "0", 10);
+  return latestMajor > currentMajor;
+}
+async function checkForUpdate() {
+  try {
+    const response = await fetch("https://registry.npmjs.org/@ncoderz/awa/latest", {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const latest = data.version;
+    if (!latest || typeof latest !== "string") return null;
+    const current = PACKAGE_INFO.version;
+    const isOutdated = compareSemver(current, latest) < 0;
+    return {
+      current,
+      latest,
+      isOutdated,
+      isMajorBump: isOutdated && isMajorVersionBump(current, latest)
+    };
+  } catch {
+    return null;
+  }
+}
+function printUpdateWarning(log, result) {
+  if (!result.isOutdated) return;
+  console.log("");
+  if (result.isMajorBump) {
+    log.warn(
+      chalk5.yellow(
+        `New major version available: ${result.current} \u2192 ${result.latest} (breaking changes)`
+      )
+    );
+    log.warn(chalk5.dim("  See https://github.com/ncoderz/awa/releases for details"));
+  } else {
+    log.warn(chalk5.yellow(`Update available: ${result.current} \u2192 ${result.latest}`));
+  }
+  log.warn(chalk5.dim("  Run `npm install -g @ncoderz/awa` to update"));
+  console.log("");
+}
+
+// src/utils/update-check-cache.ts
+import { mkdir as mkdir3, readFile as readFile6, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join as join11 } from "path";
+var CACHE_DIR = join11(homedir(), ".cache", "awa");
+var CACHE_FILE = join11(CACHE_DIR, "update-check.json");
+var DEFAULT_INTERVAL_MS = 864e5;
+async function shouldCheck(intervalMs = DEFAULT_INTERVAL_MS) {
+  try {
+    const raw = await readFile6(CACHE_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data.timestamp !== "number" || typeof data.latestVersion !== "string") {
+      return true;
+    }
+    return Date.now() - data.timestamp >= intervalMs;
+  } catch {
+    return true;
+  }
+}
+async function writeCache(latestVersion) {
+  try {
+    await mkdir3(dirname(CACHE_FILE), { recursive: true });
+    const data = {
+      timestamp: Date.now(),
+      latestVersion
+    };
+    await writeFile(CACHE_FILE, JSON.stringify(data), "utf-8");
+  } catch {
+  }
+}
+
 // src/cli/index.ts
 var version = PACKAGE_INFO.version;
 var program = new Command();
@@ -3491,7 +3051,7 @@ program.command("diff").description("Compare template output with existing targe
 });
 program.command("check").description(
   "Validate spec files against schemas and check traceability between code markers and specs"
-).option("-c, --config <path>", "Path to configuration file").option("--ignore <pattern...>", "Glob patterns for paths to exclude").option("--format <format>", "Output format (text or json)", "text").option(
+).option("-c, --config <path>", "Path to configuration file").option("--spec-ignore <pattern...>", "Glob patterns to exclude from spec file scanning").option("--code-ignore <pattern...>", "Glob patterns to exclude from code file scanning").option("--format <format>", "Output format (text or json)", "text").option(
   "--allow-warnings",
   "Allow warnings without failing (default: warnings are errors)",
   false
@@ -3502,7 +3062,8 @@ program.command("check").description(
 ).action(async (options) => {
   const cliOptions = {
     config: options.config,
-    ignore: options.ignore,
+    specIgnore: options.specIgnore,
+    codeIgnore: options.codeIgnore,
     format: options.format,
     allowWarnings: options.allowWarnings,
     specOnly: options.specOnly
@@ -3528,5 +3089,41 @@ program.command("test").description("Run template test fixtures to verify expect
   const exitCode = await testCommand(testOptions);
   process.exit(exitCode);
 });
-program.parse();
+var updateCheckPromise = null;
+var isJsonOrSummary = process.argv.includes("--json") || process.argv.includes("--summary");
+var isTTY = process.stdout.isTTY === true;
+var isDisabledByEnv = !!process.env.NO_UPDATE_NOTIFIER;
+if (!isJsonOrSummary && isTTY && !isDisabledByEnv) {
+  updateCheckPromise = (async () => {
+    try {
+      const { configLoader: configLoader2 } = await import("./config-2TOQATI3.js");
+      const configPath = process.argv.indexOf("-c") !== -1 ? process.argv[process.argv.indexOf("-c") + 1] : process.argv.indexOf("--config") !== -1 ? process.argv[process.argv.indexOf("--config") + 1] : void 0;
+      const fileConfig = await configLoader2.load(configPath ?? null);
+      const updateCheckConfig = fileConfig?.["update-check"];
+      if (updateCheckConfig?.enabled === false) return null;
+      const intervalSeconds = updateCheckConfig?.interval ?? 86400;
+      const intervalMs = intervalSeconds * 1e3;
+      const needsCheck = await shouldCheck(intervalMs);
+      if (!needsCheck) return null;
+      const result = await checkForUpdate();
+      if (result) {
+        await writeCache(result.latest);
+      }
+      return result;
+    } catch {
+      return null;
+    }
+  })();
+}
+program.hook("postAction", async () => {
+  if (!updateCheckPromise) return;
+  try {
+    const result = await updateCheckPromise;
+    if (result?.isOutdated) {
+      printUpdateWarning(logger, result);
+    }
+  } catch {
+  }
+});
+program.parseAsync();
 //# sourceMappingURL=index.js.map