@ncoderz/awa 1.7.2 → 1.8.0

package/dist/chunk-WGGMDWBE.js

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+import {
+  configLoader,
+  logger
+} from "./chunk-LRQWZCYL.js";
+
+// src/commands/renumber.ts
+import { readFile as readFile4 } from "fs/promises";
+
+// src/core/renumber/malformed-detector.ts
+var VALID_ID_RE = /^[A-Z][A-Z0-9]*(?:-\d+(?:\.\d+)?(?:_AC-\d+)?|_P-\d+|-[A-Z][a-zA-Z0-9]*)$/;
+function detectMalformed(code, fileContents) {
+  const warnings = [];
+  const esc = escapeRegex(code);
+  const tokenRegex = new RegExp(
+    `(?<![A-Za-z0-9_.-])(?:${esc}-[A-Z0-9][A-Za-z0-9_./-]*|${esc}_P-[A-Za-z0-9_./-]+)`,
+    "g"
+  );
+  for (const [filePath, content] of fileContents) {
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let match;
+      while ((match = tokenRegex.exec(line)) !== null) {
+        const token = match[0];
+        if (!VALID_ID_RE.test(token)) {
+          warnings.push({ filePath, line: i + 1, token });
+        }
+      }
+    }
+  }
+  return warnings;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/core/renumber/map-builder.ts
+import { basename } from "path";
+
+// src/core/renumber/types.ts
+var RenumberError = class extends Error {
+  errorCode;
+  constructor(errorCode, message) {
+    super(message);
+    this.name = "RenumberError";
+    this.errorCode = errorCode;
+  }
+};
+
+// src/core/renumber/map-builder.ts
+function buildRenumberMap(code, specs) {
+  const reqFile = findSpecFile(specs.specFiles, code, "REQ");
+  if (!reqFile) {
+    throw new RenumberError("CODE_NOT_FOUND", `No REQ file found for feature code: ${code}`);
+  }
+  const entries = /* @__PURE__ */ new Map();
+  buildRequirementEntries(code, reqFile, entries);
+  const designFile = findSpecFile(specs.specFiles, code, "DESIGN");
+  if (designFile) {
+    buildPropertyEntries(code, designFile, entries);
+  }
+  for (const [oldId, newId] of entries) {
+    if (oldId === newId) {
+      entries.delete(oldId);
+    }
+  }
+  const noChange = entries.size === 0;
+  const map = { code, entries };
+  return { map, noChange };
+}
+function buildRequirementEntries(code, reqFile, entries) {
+  const topLevelReqs = [];
+  const subReqsByParent = /* @__PURE__ */ new Map();
+  for (const id of reqFile.requirementIds) {
+    if (id.includes(".")) {
+      const dotIdx = id.lastIndexOf(".");
+      const parent = id.slice(0, dotIdx);
+      const subs = subReqsByParent.get(parent) ?? [];
+      subs.push(id);
+      subReqsByParent.set(parent, subs);
+    } else {
+      topLevelReqs.push(id);
+    }
+  }
+  const reqNumberMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < topLevelReqs.length; i++) {
+    const oldId = topLevelReqs[i];
+    const newNum = i + 1;
+    const newId = `${code}-${newNum}`;
+    entries.set(oldId, newId);
+    reqNumberMap.set(oldId, newNum);
+  }
+  for (const oldParentId of topLevelReqs) {
+    const subs = subReqsByParent.get(oldParentId);
+    if (!subs) continue;
+    const newParentNum = reqNumberMap.get(oldParentId);
+    if (newParentNum === void 0) continue;
+    for (let j = 0; j < subs.length; j++) {
+      const oldSubId = subs[j];
+      const newSubNum = j + 1;
+      const newSubId = `${code}-${newParentNum}.${newSubNum}`;
+      entries.set(oldSubId, newSubId);
+    }
+  }
+  const acsByParent = /* @__PURE__ */ new Map();
+  for (const acId of reqFile.acIds) {
+    const parent = acId.split("_AC-")[0];
+    const acs = acsByParent.get(parent) ?? [];
+    acs.push(acId);
+    acsByParent.set(parent, acs);
+  }
+  for (const [oldParentId, acs] of acsByParent) {
+    const newParentId = entries.get(oldParentId) ?? oldParentId;
+    for (let k = 0; k < acs.length; k++) {
+      const oldAcId = acs[k];
+      const newAcNum = k + 1;
+      const newAcId = `${newParentId}_AC-${newAcNum}`;
+      entries.set(oldAcId, newAcId);
+    }
+  }
+}
+function buildPropertyEntries(code, designFile, entries) {
+  for (let i = 0; i < designFile.propertyIds.length; i++) {
+    const oldId = designFile.propertyIds[i];
+    const newNum = i + 1;
+    const newId = `${code}_P-${newNum}`;
+    entries.set(oldId, newId);
+  }
+}
+function findSpecFile(specFiles, code, prefix) {
+  return specFiles.find((sf) => {
+    const name = basename(sf.filePath);
+    return name.startsWith(`${prefix}-${code}-`);
+  });
+}
+
+// src/core/renumber/propagator.ts
+import { readFile, writeFile } from "fs/promises";
+async function propagate(map, specs, markers, dryRun) {
+  if (map.entries.size === 0) {
+    return { affectedFiles: [], totalReplacements: 0 };
+  }
+  const filePaths = collectFilePaths(map, specs, markers);
+  const affectedFiles = [];
+  let totalReplacements = 0;
+  for (const filePath of filePaths) {
+    let content;
+    try {
+      content = await readFile(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const result = applyReplacements(content, map);
+    if (result.replacements.length === 0) continue;
+    affectedFiles.push({ filePath, replacements: result.replacements });
+    totalReplacements += result.replacements.length;
+    if (!dryRun) {
+      try {
+        await writeFile(filePath, result.newContent, "utf-8");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new RenumberError("WRITE_FAILED", `Failed to write ${filePath}: ${msg}`);
+      }
+    }
+  }
+  return { affectedFiles, totalReplacements };
+}
+function collectFilePaths(map, specs, markers) {
+  const paths = /* @__PURE__ */ new Set();
+  const code = map.code;
+  for (const specFile of specs.specFiles) {
+    paths.add(specFile.filePath);
+  }
+  const affectedIds = new Set(map.entries.keys());
+  for (const marker of markers.markers) {
+    if (affectedIds.has(marker.id) || hasCodePrefix(marker.id, code)) {
+      paths.add(marker.filePath);
+    }
+  }
+  return [...paths];
+}
+function applyReplacements(content, map) {
+  const replacements = [];
+  const lines = content.split("\n");
+  const sortedEntries = [...map.entries].sort(([a], [b]) => b.length - a.length);
+  const placeholders = /* @__PURE__ */ new Map();
+  const placeholderToNew = /* @__PURE__ */ new Map();
+  for (const [oldId, newId] of sortedEntries) {
+    const placeholder = `__RENUM_${placeholders.size}__`;
+    placeholders.set(oldId, placeholder);
+    placeholderToNew.set(placeholder, newId);
+  }
+  for (let idx = 0; idx < lines.length; idx++) {
+    let modified = lines[idx];
+    const origLine = modified;
+    for (const [oldId, placeholder] of placeholders) {
+      const regex = buildWholeIdRegex(oldId);
+      const trackRegex = buildWholeIdRegex(oldId);
+      while (trackRegex.exec(origLine) !== null) {
+        replacements.push({
+          line: idx + 1,
+          oldId,
+          newId: map.entries.get(oldId) ?? oldId
+        });
+      }
+      modified = modified.replace(regex, placeholder);
+    }
+    for (const [placeholder, newId] of placeholderToNew) {
+      modified = modified.replaceAll(placeholder, newId);
+    }
+    lines[idx] = modified;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const dedupedReplacements = replacements.filter((r) => {
+    const key = `${r.line}:${r.oldId}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return { newContent: lines.join("\n"), replacements: dedupedReplacements };
+}
+function buildWholeIdRegex(id) {
+  const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?<![A-Za-z0-9_.-])${escaped}(?![A-Za-z0-9_.-])`, "g");
+}
+function hasCodePrefix(id, code) {
+  return id.startsWith(`${code}-`) || id.startsWith(`${code}_`);
+}
+
+// src/core/renumber/reporter.ts
+function formatText(result, dryRun) {
+  const lines = [];
+  if (dryRun) {
+    lines.push("DRY RUN \u2014 no files were modified\n");
+  }
+  if (result.noChange) {
+    lines.push(`${result.code}: no changes needed (IDs already sequential)`);
+    return lines.join("\n");
+  }
+  lines.push(`${result.code}: ${result.map.entries.size} ID(s) renumbered
+`);
+  lines.push("  Old ID \u2192 New ID");
+  lines.push(`  ${"\u2500".repeat(40)}`);
+  for (const [oldId, newId] of result.map.entries) {
+    lines.push(`  ${oldId} \u2192 ${newId}`);
+  }
+  if (result.affectedFiles.length > 0) {
+    lines.push("");
+    lines.push(
+      `  ${result.totalReplacements} replacement(s) in ${result.affectedFiles.length} file(s):`
+    );
+    for (const file of result.affectedFiles) {
+      lines.push(`    ${file.filePath} (${file.replacements.length})`);
+    }
+  }
+  if (result.malformedWarnings.length > 0) {
+    lines.push("");
+    lines.push("  Malformed ID warnings:");
+    for (const w of result.malformedWarnings) {
+      lines.push(`    ${w.filePath}:${w.line} \u2014 ${w.token}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatJson(result) {
+  const output = {
+    code: result.code,
+    noChange: result.noChange,
+    map: Object.fromEntries(result.map.entries),
+    affectedFiles: result.affectedFiles.map((f) => ({
+      filePath: f.filePath,
+      replacements: f.replacements.map((r) => ({
+        line: r.line,
+        oldId: r.oldId,
+        newId: r.newId
+      }))
+    })),
+    totalReplacements: result.totalReplacements,
+    malformedWarnings: result.malformedWarnings.map((w) => ({
+      filePath: w.filePath,
+      line: w.line,
+      token: w.token
+    }))
+  };
+  return JSON.stringify(output, null, 2);
+}
+
+// src/core/check/marker-scanner.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/core/check/glob.ts
+import { glob } from "fs/promises";
+function matchSimpleGlob(path, pattern) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*");
+  return new RegExp(`(^|/)${regex}($|/)`).test(path);
+}
+async function collectFiles(globs, ignore) {
+  const files = [];
+  const dirPrefixes = ignore.filter((ig) => ig.endsWith("/**")).map((ig) => ig.slice(0, -3));
+  const compiledIgnore = ignore.map((ig) => {
+    const regex = ig.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*");
+    return new RegExp(`(^|/)${regex}($|/)`);
+  });
+  for (const pattern of globs) {
+    for await (const filePath of glob(pattern, {
+      exclude: (p) => dirPrefixes.includes(p) || compiledIgnore.some((re) => re.test(p))
+    })) {
+      if (!compiledIgnore.some((re) => re.test(filePath))) {
+        files.push(filePath);
+      }
+    }
+  }
+  return [...new Set(files)];
+}
+
+// src/core/check/marker-scanner.ts
+var MARKER_TYPE_MAP = {
+  "@awa-impl": "impl",
+  "@awa-test": "test",
+  "@awa-component": "component"
+};
+var IGNORE_FILE_RE = new RegExp("@awa-ignore-file\\b");
+var IGNORE_NEXT_LINE_RE = /@awa-ignore-next-line\b/;
+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.codeIgnore);
+  const markers = [];
+  const findings = [];
+  for (const filePath of files) {
+    if (config.ignoreMarkers.some((ig) => matchSimpleGlob(filePath, ig))) {
+      continue;
+    }
+    const result = await scanFile(filePath, config.markers);
+    markers.push(...result.markers);
+    findings.push(...result.findings);
+  }
+  return { markers, findings };
+}
+function buildMarkerRegex(markerNames) {
+  const escaped = markerNames.map((m) => m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`(${escaped.join("|")}):\\s*(.+)`, "g");
+}
+var ID_TOKEN_RE = /^([A-Z][A-Z0-9]*(?:[-_][A-Za-z0-9]+)*(?:\.\d+)?(?:[-_][A-Za-z0-9]+)*)/;
+async function scanFile(filePath, markerNames) {
+  let content;
+  try {
+    content = await readFile2(filePath, "utf-8");
+  } catch {
+    return { markers: [], findings: [] };
+  }
+  if (IGNORE_FILE_RE.test(content)) {
+    return { markers: [], findings: [] };
+  }
+  const regex = buildMarkerRegex(markerNames);
+  const lines = content.split("\n");
+  const markers = [];
+  const findings = [];
+  let ignoreNextLine = false;
+  let ignoreBlock = false;
+  for (const [i, line] of lines.entries()) {
+    if (IGNORE_START_RE.test(line)) {
+      ignoreBlock = true;
+      continue;
+    }
+    if (IGNORE_END_RE.test(line)) {
+      ignoreBlock = false;
+      continue;
+    }
+    if (ignoreBlock) {
+      continue;
+    }
+    if (ignoreNextLine) {
+      ignoreNextLine = false;
+      continue;
+    }
+    if (IGNORE_NEXT_LINE_RE.test(line)) {
+      ignoreNextLine = true;
+      continue;
+    }
+    if (IGNORE_LINE_RE.test(line)) {
+      continue;
+    }
+    regex.lastIndex = 0;
+    let match = regex.exec(line);
+    while (match !== null) {
+      const markerName = match[1] ?? "";
+      const idsRaw = match[2] ?? "";
+      const type = resolveMarkerType(markerName, markerNames);
+      const ids = idsRaw.split(",").map((id) => id.trim()).filter(Boolean);
+      for (const id of ids) {
+        const tokenMatch = ID_TOKEN_RE.exec(id);
+        const cleanId = tokenMatch?.[1]?.trim() ?? "";
+        if (cleanId && tokenMatch) {
+          const remainder = id.slice(tokenMatch[0].length).trim();
+          if (remainder) {
+            findings.push({
+              severity: "error",
+              code: "marker-trailing-text",
+              message: `Marker has trailing text after ID '${cleanId}': '${remainder}' \u2014 use comma-separated IDs only`,
+              filePath,
+              line: i + 1,
+              id: cleanId
+            });
+          }
+          markers.push({ type, id: cleanId, filePath, line: i + 1 });
+        }
+      }
+      match = regex.exec(line);
+    }
+  }
+  return { markers, findings };
+}
+function resolveMarkerType(markerName, configuredMarkers) {
+  const mapped = MARKER_TYPE_MAP[markerName];
+  if (mapped) return mapped;
+  const idx = configuredMarkers.indexOf(markerName);
+  if (idx === 1) return "test";
+  if (idx === 2) return "component";
+  return "impl";
+}
+async function collectCodeFiles(codeGlobs, ignore) {
+  return collectFiles(codeGlobs, ignore);
+}
+
+// src/core/check/spec-parser.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename as basename2 } from "path";
+async function parseSpecs(config) {
+  const files = await collectSpecFiles(config.specGlobs, config.specIgnore);
+  const specFiles = [];
+  const requirementIds = /* @__PURE__ */ new Set();
+  const acIds = /* @__PURE__ */ new Set();
+  const propertyIds = /* @__PURE__ */ new Set();
+  const componentNames = /* @__PURE__ */ new Set();
+  const idLocations = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const specFile = await parseSpecFile(filePath, config.crossRefPatterns);
+    if (specFile) {
+      specFiles.push(specFile);
+      for (const id of specFile.requirementIds) requirementIds.add(id);
+      for (const id of specFile.acIds) acIds.add(id);
+      for (const id of specFile.propertyIds) propertyIds.add(id);
+      for (const name of specFile.componentNames) componentNames.add(name);
+      for (const [id, loc] of specFile.idLocations ?? []) {
+        idLocations.set(id, loc);
+      }
+    }
+  }
+  const allIds = /* @__PURE__ */ new Set([...requirementIds, ...acIds, ...propertyIds, ...componentNames]);
+  return { requirementIds, acIds, propertyIds, componentNames, allIds, specFiles, idLocations };
+}
+async function parseSpecFile(filePath, crossRefPatterns) {
+  let content;
+  try {
+    content = await readFile3(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const code = extractCodePrefix(filePath);
+  const lines = content.split("\n");
+  const requirementIds = [];
+  const acIds = [];
+  const propertyIds = [];
+  const componentNames = [];
+  const crossRefs = [];
+  const idLocations = /* @__PURE__ */ new Map();
+  const componentImplements = /* @__PURE__ */ new Map();
+  const reqIdRegex = /^###\s+([A-Z][A-Z0-9]*-\d+(?:\.\d+)?)\s*:/;
+  const acIdRegex = /^-\s+(?:\[[ x]\]\s+)?([A-Z][A-Z0-9]*-\d+(?:\.\d+)?_AC-\d+)\s/;
+  const propIdRegex = /^-\s+([A-Z][A-Z0-9]*_P-\d+)\s/;
+  const componentRegex = /^###\s+([A-Z][A-Z0-9]*-[A-Za-z][A-Za-z0-9]*(?:[A-Z][a-z0-9]*)*)\s*$/;
+  let currentComponent = null;
+  for (const [i, line] of lines.entries()) {
+    const lineNum = i + 1;
+    const reqMatch = reqIdRegex.exec(line);
+    if (reqMatch?.[1]) {
+      requirementIds.push(reqMatch[1]);
+      idLocations.set(reqMatch[1], { filePath, line: lineNum });
+    }
+    const acMatch = acIdRegex.exec(line);
+    if (acMatch?.[1]) {
+      acIds.push(acMatch[1]);
+      idLocations.set(acMatch[1], { filePath, line: lineNum });
+    }
+    const propMatch = propIdRegex.exec(line);
+    if (propMatch?.[1]) {
+      propertyIds.push(propMatch[1]);
+      idLocations.set(propMatch[1], { filePath, line: lineNum });
+    }
+    const compMatch = componentRegex.exec(line);
+    if (compMatch?.[1]) {
+      if (!reqIdRegex.test(line)) {
+        componentNames.push(compMatch[1]);
+        idLocations.set(compMatch[1], { filePath, line: lineNum });
+        currentComponent = compMatch[1];
+      }
+    }
+    if (/^#{1,2}\s/.test(line) && !compMatch) {
+      currentComponent = null;
+    }
+    for (const pattern of crossRefPatterns) {
+      const patIdx = line.indexOf(pattern);
+      if (patIdx !== -1) {
+        const afterPattern = line.slice(patIdx + pattern.length);
+        const ids = extractIdsFromText(afterPattern);
+        if (ids.length > 0) {
+          const type = pattern.toLowerCase().includes("implements") ? "implements" : "validates";
+          crossRefs.push({ type, ids, filePath, line: i + 1 });
+          if (type === "implements" && currentComponent) {
+            const existing = componentImplements.get(currentComponent) ?? [];
+            existing.push(...ids);
+            componentImplements.set(currentComponent, existing);
+          }
+        }
+      }
+    }
+  }
+  return {
+    filePath,
+    code,
+    requirementIds,
+    acIds,
+    propertyIds,
+    componentNames,
+    crossRefs,
+    idLocations,
+    componentImplements,
+    content
+  };
+}
+function extractCodePrefix(filePath) {
+  const name = basename2(filePath, ".md");
+  const match = /^(?:REQ|DESIGN|FEAT|EXAMPLE|API)-([A-Z][A-Z0-9]*)-/.exec(name);
+  if (match?.[1]) return match[1];
+  return "";
+}
+function extractIdsFromText(text) {
+  const idRegex = /[A-Z][A-Z0-9]*-\d+(?:\.\d+)?(?:_AC-\d+)?|[A-Z][A-Z0-9]*_P-\d+/g;
+  const ids = [];
+  let match = idRegex.exec(text);
+  while (match !== null) {
+    ids.push(match[0]);
+    match = idRegex.exec(text);
+  }
+  return ids;
+}
+async function collectSpecFiles(specGlobs, ignore) {
+  return collectFiles(specGlobs, ignore);
+}
+
+// src/core/check/types.ts
+var DEFAULT_CHECK_CONFIG = {
+  specGlobs: [
+    ".awa/specs/ARCHITECTURE.md",
+    ".awa/specs/FEAT-*.md",
+    ".awa/specs/REQ-*.md",
+    ".awa/specs/DESIGN-*.md",
+    ".awa/specs/EXAMPLE-*.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+)",
+  crossRefPatterns: ["IMPLEMENTS:", "VALIDATES:"],
+  format: "text",
+  schemaDir: ".awa/.agent/schemas",
+  schemaEnabled: true,
+  allowWarnings: false,
+  specOnly: false,
+  fix: true
+};
+
+// src/core/trace/scanner.ts
+function buildScanConfig(fileConfig, overrides) {
+  const section = fileConfig?.check;
+  return {
+    specGlobs: toStringArray(section?.["spec-globs"]) ?? [...DEFAULT_CHECK_CONFIG.specGlobs],
+    codeGlobs: toStringArray(section?.["code-globs"]) ?? [...DEFAULT_CHECK_CONFIG.codeGlobs],
+    specIgnore: toStringArray(section?.["spec-ignore"]) ?? [...DEFAULT_CHECK_CONFIG.specIgnore],
+    codeIgnore: toStringArray(section?.["code-ignore"]) ?? [...DEFAULT_CHECK_CONFIG.codeIgnore],
+    ignoreMarkers: toStringArray(section?.["ignore-markers"]) ?? [
+      ...DEFAULT_CHECK_CONFIG.ignoreMarkers
+    ],
+    markers: toStringArray(section?.markers) ?? [...DEFAULT_CHECK_CONFIG.markers],
+    idPattern: typeof section?.["id-pattern"] === "string" ? section["id-pattern"] : DEFAULT_CHECK_CONFIG.idPattern,
+    crossRefPatterns: toStringArray(section?.["cross-ref-patterns"]) ?? [
+      ...DEFAULT_CHECK_CONFIG.crossRefPatterns
+    ],
+    format: DEFAULT_CHECK_CONFIG.format,
+    schemaDir: DEFAULT_CHECK_CONFIG.schemaDir,
+    schemaEnabled: false,
+    allowWarnings: true,
+    specOnly: false,
+    fix: true,
+    ...overrides
+  };
+}
+async function scan(configPath) {
+  const fileConfig = await configLoader.load(configPath ?? null);
+  const config = buildScanConfig(fileConfig);
+  const [markers, specs] = await Promise.all([scanMarkers(config), parseSpecs(config)]);
+  return { markers, specs, config };
+}
+function toStringArray(value) {
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  return null;
+}
+
+// src/commands/renumber.ts
+async function renumberCommand(options) {
+  try {
+    if (!options.code && !options.all) {
+      logger.error("No feature code or --all specified");
+      return 2;
+    }
+    const { markers, specs } = await scan(options.config);
+    let codes;
+    if (options.all) {
+      codes = discoverFeatureCodes(specs.specFiles);
+      if (codes.length === 0) {
+        logger.warn("No feature codes discovered from REQ files");
+        return 0;
+      }
+    } else {
+      codes = [options.code];
+    }
+    const dryRun = options.dryRun === true;
+    const results = [];
+    let hasChanges = false;
+    for (const code of codes) {
+      try {
+        const result = await runRenumberPipeline(code, specs, markers, dryRun);
+        results.push(result);
+        if (!result.noChange) {
+          hasChanges = true;
+        }
+      } catch (err) {
+        if (err instanceof RenumberError && err.errorCode === "CODE_NOT_FOUND") {
+          logger.error(err.message);
+          return 2;
+        }
+        throw err;
+      }
+    }
+    if (options.json) {
+      if (results.length === 1) {
+        const first = results[0];
+        process.stdout.write(`${formatJson(first)}
+`);
+      } else {
+        const jsonArray = results.map((r) => JSON.parse(formatJson(r)));
+        process.stdout.write(`${JSON.stringify(jsonArray, null, 2)}
+`);
+      }
+    } else {
+      for (const result of results) {
+        const text = formatText(result, dryRun);
+        logger.info(text);
+      }
+    }
+    return hasChanges ? 1 : 0;
+  } catch (err) {
+    if (err instanceof RenumberError) {
+      logger.error(err.message);
+      return 2;
+    }
+    if (err instanceof Error) {
+      logger.error(err.message);
+    } else {
+      logger.error(String(err));
+    }
+    return 2;
+  }
+}
+async function runRenumberPipeline(code, specs, markers, dryRun) {
+  const { map, noChange } = buildRenumberMap(code, specs);
+  if (noChange) {
+    return {
+      code,
+      map,
+      affectedFiles: [],
+      totalReplacements: 0,
+      malformedWarnings: [],
+      noChange: true
+    };
+  }
+  const { affectedFiles, totalReplacements } = await propagate(map, specs, markers, dryRun);
+  const fileContents = await collectFileContents(specs, markers, code);
+  const malformedWarnings = detectMalformed(code, fileContents);
+  return {
+    code,
+    map,
+    affectedFiles,
+    totalReplacements,
+    malformedWarnings,
+    noChange: false
+  };
+}
+function discoverFeatureCodes(specFiles) {
+  const codes = /* @__PURE__ */ new Set();
+  for (const sf of specFiles) {
+    if (sf.code && /^REQ-/.test(sf.filePath.split("/").pop() ?? "")) {
+      codes.add(sf.code);
+    }
+  }
+  return [...codes].sort();
+}
+async function collectFileContents(specs, markers, code) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const sf of specs.specFiles) {
+    paths.add(sf.filePath);
+  }
+  for (const m of markers.markers) {
+    if (m.id.startsWith(`${code}-`) || m.id.startsWith(`${code}_`)) {
+      paths.add(m.filePath);
+    }
+  }
+  const contents = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    try {
+      const content = await readFile4(p, "utf-8");
+      contents.set(p, content);
+    } catch {
+    }
+  }
+  return contents;
+}
+
+export {
+  matchSimpleGlob,
+  collectFiles,
+  scanMarkers,
+  parseSpecs,
+  DEFAULT_CHECK_CONFIG,
+  scan,
+  propagate,
+  renumberCommand
+};
+//# sourceMappingURL=chunk-WGGMDWBE.js.map