lula2 0.0.5 → 0.0.6

package/dist/cli/server/serverState.js

@@ -0,0 +1,1199 @@
+// cli/server/serverState.ts
+import { join as join3 } from "path";
+
+// cli/utils/debug.ts
+var debugEnabled = false;
+function debug(...args) {
+  if (debugEnabled) {
+    console.log("[DEBUG]", ...args);
+  }
+}
+
+// cli/server/infrastructure/fileStore.ts
+import {
+  existsSync as existsSync2,
+  promises as fs,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import * as yaml2 from "js-yaml";
+import { join as join2 } from "path";
+
+// cli/server/infrastructure/controlHelpers.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import * as yaml from "js-yaml";
+var controlSetMetadata = null;
+var metadataPath = null;
+function loadControlSetMetadata(baseDir) {
+  const path = join(baseDir, "lula.yaml");
+  if (metadataPath !== path || !controlSetMetadata) {
+    if (existsSync(path)) {
+      try {
+        const content = readFileSync(path, "utf8");
+        controlSetMetadata = yaml.load(content);
+        metadataPath = path;
+      } catch (error) {
+        console.error(`Failed to parse lula.yaml at ${path}:`, error);
+        controlSetMetadata = {};
+        metadataPath = path;
+      }
+    } else {
+      controlSetMetadata = {};
+      metadataPath = path;
+    }
+  }
+  return controlSetMetadata;
+}
+function getControlIdField(baseDir) {
+  if (baseDir) {
+    loadControlSetMetadata(baseDir);
+  }
+  return controlSetMetadata?.control_id_field || "id";
+}
+function getControlId(control, baseDir) {
+  if (!control || typeof control !== "object") {
+    throw new Error("Invalid control object provided");
+  }
+  const idField = getControlIdField(baseDir);
+  const configuredId = control[idField];
+  if (configuredId && typeof configuredId === "string") {
+    return configuredId;
+  }
+  if (idField !== "id" && control.id) {
+    return control.id;
+  }
+  const possibleIdFields = [
+    "ap-acronym",
+    "control-id",
+    "control_id",
+    "controlId"
+  ];
+  for (const field of possibleIdFields) {
+    const value = control[field];
+    if (value && typeof value === "string") {
+      return value;
+    }
+  }
+  const availableFields = Object.keys(control).filter(
+    (key) => control[key] !== void 0
+  );
+  throw new Error(
+    `No control ID found in control object. Available fields: ${availableFields.join(", ")}`
+  );
+}
+
+// cli/server/infrastructure/fileStore.ts
+var FileStore = class {
+  baseDir;
+  controlsDir;
+  mappingsDir;
+  // Simple cache - just control ID to filename mapping
+  controlMetadataCache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.baseDir = options.baseDir;
+    this.controlsDir = join2(this.baseDir, "controls");
+    this.mappingsDir = join2(this.baseDir, "mappings");
+    if (existsSync2(this.controlsDir)) {
+      this.refreshControlsCache();
+    }
+  }
+  /**
+   * Get simple filename from control ID
+   */
+  getControlFilename(controlId) {
+    const sanitized = controlId.replace(/[^\w\-]/g, "_");
+    return `${sanitized}.yaml`;
+  }
+  /**
+   * Get family name from control ID
+   */
+  getControlFamily(controlId) {
+    return controlId.split("-")[0];
+  }
+  /**
+   * Ensure required directories exist
+   */
+  ensureDirectories() {
+    if (!this.baseDir || this.baseDir === "." || this.baseDir === process.cwd()) {
+      return;
+    }
+    const lulaConfigPath = join2(this.baseDir, "lula.yaml");
+    if (!existsSync2(lulaConfigPath)) {
+      return;
+    }
+    if (!existsSync2(this.controlsDir)) {
+      mkdirSync(this.controlsDir, { recursive: true });
+    }
+    if (!existsSync2(this.mappingsDir)) {
+      mkdirSync(this.mappingsDir, { recursive: true });
+    }
+  }
+  /**
+   * Get control metadata by ID
+   */
+  getControlMetadata(controlId) {
+    return this.controlMetadataCache.get(controlId);
+  }
+  /**
+   * Load a control by ID
+   */
+  async loadControl(controlId) {
+    const sanitizedId = controlId.replace(/[^\w\-]/g, "_");
+    const possibleFlatPaths = [
+      join2(this.controlsDir, `${controlId}.yaml`),
+      join2(this.controlsDir, `${sanitizedId}.yaml`)
+    ];
+    for (const flatFilePath of possibleFlatPaths) {
+      if (existsSync2(flatFilePath)) {
+        try {
+          const content = readFileSync2(flatFilePath, "utf8");
+          const parsed = yaml2.load(content);
+          if (!parsed.id) {
+            parsed.id = controlId.replace(/_(\d)/g, ".$1");
+          }
+          return parsed;
+        } catch (error) {
+          console.error(`Failed to load control ${controlId} from flat structure:`, error);
+          throw new Error(
+            `Failed to load control ${controlId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    const family = this.getControlFamily(controlId);
+    const familyDir = join2(this.controlsDir, family);
+    const possibleFamilyPaths = [
+      join2(familyDir, `${controlId}.yaml`),
+      join2(familyDir, `${sanitizedId}.yaml`)
+    ];
+    for (const filePath of possibleFamilyPaths) {
+      if (existsSync2(filePath)) {
+        try {
+          const content = readFileSync2(filePath, "utf8");
+          const parsed = yaml2.load(content);
+          if (!parsed.id) {
+            parsed.id = controlId.replace(/_(\d)/g, ".$1");
+          }
+          return parsed;
+        } catch (error) {
+          console.error(`Failed to load control ${controlId}:`, error);
+          throw new Error(
+            `Failed to load control ${controlId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Save a control
+   */
+  async saveControl(control) {
+    this.ensureDirectories();
+    const controlId = getControlId(control, this.baseDir);
+    const family = this.getControlFamily(controlId);
+    const filename = this.getControlFilename(controlId);
+    const familyDir = join2(this.controlsDir, family);
+    const filePath = join2(familyDir, filename);
+    if (!existsSync2(familyDir)) {
+      mkdirSync(familyDir, { recursive: true });
+    }
+    try {
+      let yamlContent;
+      if (existsSync2(filePath)) {
+        const existingContent = readFileSync2(filePath, "utf8");
+        const existingControl = yaml2.load(existingContent);
+        const fieldsToUpdate = {};
+        for (const key in control) {
+          if (key === "timeline" || key === "unifiedHistory" || key === "_metadata" || key === "id") {
+            continue;
+          }
+          if (JSON.stringify(control[key]) !== JSON.stringify(existingControl[key])) {
+            fieldsToUpdate[key] = control[key];
+          }
+        }
+        if (Object.keys(fieldsToUpdate).length > 0) {
+          const updatedControl = { ...existingControl, ...fieldsToUpdate };
+          yamlContent = yaml2.dump(updatedControl, {
+            indent: 2,
+            lineWidth: 80,
+            noRefs: true,
+            sortKeys: false
+          });
+        } else {
+          yamlContent = existingContent;
+        }
+      } else {
+        const controlToSave = { ...control };
+        delete controlToSave.timeline;
+        delete controlToSave.unifiedHistory;
+        delete controlToSave._metadata;
+        delete controlToSave.id;
+        yamlContent = yaml2.dump(controlToSave, {
+          indent: 2,
+          lineWidth: 80,
+          noRefs: true,
+          sortKeys: false
+        });
+      }
+      writeFileSync(filePath, yamlContent, "utf8");
+      this.controlMetadataCache.set(controlId, {
+        controlId,
+        filename,
+        family
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to save control ${controlId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Delete a control
+   */
+  async deleteControl(controlId) {
+    const family = this.getControlFamily(controlId);
+    const filename = this.getControlFilename(controlId);
+    const familyDir = join2(this.controlsDir, family);
+    const filePath = join2(familyDir, filename);
+    if (existsSync2(filePath)) {
+      unlinkSync(filePath);
+      this.controlMetadataCache.delete(controlId);
+    }
+  }
+  /**
+   * Load all controls
+   */
+  async loadAllControls() {
+    if (!existsSync2(this.controlsDir)) {
+      return [];
+    }
+    const entries = readdirSync(this.controlsDir);
+    const yamlFiles = entries.filter((file) => file.endsWith(".yaml"));
+    if (yamlFiles.length > 0) {
+      const promises = yamlFiles.map(async (file) => {
+        try {
+          const filePath = join2(this.controlsDir, file);
+          const content = await fs.readFile(filePath, "utf8");
+          const parsed = yaml2.load(content);
+          if (!parsed.id) {
+            parsed.id = getControlId(parsed, this.baseDir);
+          }
+          return parsed;
+        } catch (error) {
+          console.error(`Failed to load control from file ${file}:`, error);
+          return null;
+        }
+      });
+      const results2 = await Promise.all(promises);
+      return results2.filter((c) => c !== null);
+    }
+    const families = entries.filter((name) => {
+      const familyPath = join2(this.controlsDir, name);
+      return statSync(familyPath).isDirectory();
+    });
+    const allPromises = [];
+    for (const family of families) {
+      const familyPath = join2(this.controlsDir, family);
+      const files = readdirSync(familyPath).filter((file) => file.endsWith(".yaml"));
+      const familyPromises = files.map(async (file) => {
+        try {
+          const controlId = file.replace(".yaml", "");
+          const control = await this.loadControl(controlId);
+          return control;
+        } catch (error) {
+          console.error(`Failed to load control from file ${file}:`, error);
+          return null;
+        }
+      });
+      allPromises.push(...familyPromises);
+    }
+    const results = await Promise.all(allPromises);
+    return results.filter((c) => c !== null);
+  }
+  /**
+   * Load mappings from mappings directory
+   */
+  async loadMappings() {
+    const mappings = [];
+    if (!existsSync2(this.mappingsDir)) {
+      return mappings;
+    }
+    const families = readdirSync(this.mappingsDir).filter((name) => {
+      const familyPath = join2(this.mappingsDir, name);
+      return statSync(familyPath).isDirectory();
+    });
+    for (const family of families) {
+      const familyPath = join2(this.mappingsDir, family);
+      const files = readdirSync(familyPath).filter((file) => file.endsWith("-mappings.yaml"));
+      for (const file of files) {
+        const mappingFile = join2(familyPath, file);
+        try {
+          const content = readFileSync2(mappingFile, "utf8");
+          const parsed = yaml2.load(content);
+          if (Array.isArray(parsed)) {
+            mappings.push(...parsed);
+          }
+        } catch (error) {
+          console.error(`Failed to load mappings from ${family}/${file}:`, error);
+        }
+      }
+    }
+    return mappings;
+  }
+  /**
+   * Save a single mapping
+   */
+  async saveMapping(mapping) {
+    this.ensureDirectories();
+    const controlId = mapping.control_id;
+    const family = this.getControlFamily(controlId);
+    const familyDir = join2(this.mappingsDir, family);
+    const mappingFile = join2(familyDir, `${controlId}-mappings.yaml`);
+    if (!existsSync2(familyDir)) {
+      mkdirSync(familyDir, { recursive: true });
+    }
+    let existingMappings = [];
+    if (existsSync2(mappingFile)) {
+      try {
+        const content = readFileSync2(mappingFile, "utf8");
+        existingMappings = yaml2.load(content) || [];
+      } catch (error) {
+        console.error(`Failed to parse existing mappings file: ${mappingFile}`, error);
+        existingMappings = [];
+      }
+    }
+    const existingIndex = existingMappings.findIndex((m) => m.uuid === mapping.uuid);
+    if (existingIndex >= 0) {
+      existingMappings[existingIndex] = mapping;
+    } else {
+      existingMappings.push(mapping);
+    }
+    try {
+      const yamlContent = yaml2.dump(existingMappings, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true
+      });
+      writeFileSync(mappingFile, yamlContent, "utf8");
+    } catch (error) {
+      throw new Error(
+        `Failed to save mapping for control ${controlId}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Delete a single mapping
+   */
+  async deleteMapping(uuid) {
+    const mappingFiles = this.getAllMappingFiles();
+    for (const file of mappingFiles) {
+      try {
+        const content = readFileSync2(file, "utf8");
+        let mappings = yaml2.load(content) || [];
+        const originalLength = mappings.length;
+        mappings = mappings.filter((m) => m.uuid !== uuid);
+        if (mappings.length < originalLength) {
+          if (mappings.length === 0) {
+            unlinkSync(file);
+          } else {
+            const yamlContent = yaml2.dump(mappings, {
+              indent: 2,
+              lineWidth: -1,
+              noRefs: true
+            });
+            writeFileSync(file, yamlContent, "utf8");
+          }
+          return;
+        }
+      } catch (error) {
+        console.error(`Error processing mapping file ${file}:`, error);
+      }
+    }
+  }
+  /**
+   * Get all mapping files
+   */
+  getAllMappingFiles() {
+    const files = [];
+    if (!existsSync2(this.mappingsDir)) {
+      return files;
+    }
+    const flatFiles = readdirSync(this.mappingsDir).filter((file) => file.endsWith("-mappings.yaml")).map((file) => join2(this.mappingsDir, file));
+    files.push(...flatFiles);
+    const entries = readdirSync(this.mappingsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const familyDir = join2(this.mappingsDir, entry.name);
+        const familyFiles = readdirSync(familyDir).filter((file) => file.endsWith("-mappings.yaml")).map((file) => join2(familyDir, file));
+        files.push(...familyFiles);
+      }
+    }
+    return files;
+  }
+  /**
+   * Save mappings to per-control files
+   */
+  async saveMappings(mappings) {
+    this.ensureDirectories();
+    const mappingsByControl = /* @__PURE__ */ new Map();
+    for (const mapping of mappings) {
+      const controlId = mapping.control_id;
+      if (!mappingsByControl.has(controlId)) {
+        mappingsByControl.set(controlId, []);
+      }
+      mappingsByControl.get(controlId).push(mapping);
+    }
+    for (const [controlId, controlMappings] of mappingsByControl) {
+      const family = this.getControlFamily(controlId);
+      const familyDir = join2(this.mappingsDir, family);
+      const mappingFile = join2(familyDir, `${controlId}-mappings.yaml`);
+      if (!existsSync2(familyDir)) {
+        mkdirSync(familyDir, { recursive: true });
+      }
+      try {
+        const yamlContent = yaml2.dump(controlMappings, {
+          indent: 2,
+          lineWidth: -1,
+          noRefs: true
+        });
+        writeFileSync(mappingFile, yamlContent, "utf8");
+      } catch (error) {
+        throw new Error(
+          `Failed to save mappings for control ${controlId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Refresh controls cache
+   */
+  refreshControlsCache() {
+    this.controlMetadataCache.clear();
+    if (!existsSync2(this.controlsDir)) {
+      return;
+    }
+    const entries = readdirSync(this.controlsDir);
+    const yamlFiles = entries.filter((file) => file.endsWith(".yaml"));
+    if (yamlFiles.length > 0) {
+      for (const filename of yamlFiles) {
+        const controlId = filename.replace(".yaml", "");
+        const family = this.getControlFamily(controlId);
+        this.controlMetadataCache.set(controlId, {
+          controlId,
+          filename,
+          family
+        });
+      }
+      return;
+    }
+    const families = entries.filter((name) => {
+      const familyPath = join2(this.controlsDir, name);
+      return statSync(familyPath).isDirectory();
+    });
+    for (const family of families) {
+      const familyPath = join2(this.controlsDir, family);
+      const files = readdirSync(familyPath).filter((file) => file.endsWith(".yaml"));
+      for (const filename of files) {
+        try {
+          const filePath = join2(familyPath, filename);
+          const content = readFileSync2(filePath, "utf8");
+          const parsed = yaml2.load(content);
+          const controlId = getControlId(parsed, this.baseDir);
+          this.controlMetadataCache.set(controlId, {
+            controlId,
+            filename,
+            family
+          });
+        } catch (error) {
+          console.error(`Failed to read control metadata from ${family}/${filename}:`, error);
+          const controlId = filename.replace(".yaml", "").replace(/_/g, "/");
+          this.controlMetadataCache.set(controlId, {
+            controlId,
+            filename,
+            family
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Get file store statistics
+   */
+  getStats() {
+    const controlCount = this.controlMetadataCache.size;
+    let mappingCount = 0;
+    if (existsSync2(this.mappingsDir)) {
+      const families = readdirSync(this.mappingsDir).filter((name) => {
+        const familyPath = join2(this.mappingsDir, name);
+        return statSync(familyPath).isDirectory();
+      });
+      mappingCount = families.length;
+    }
+    const familyCount = new Set(
+      Array.from(this.controlMetadataCache.values()).map((meta) => meta.family)
+    ).size;
+    return {
+      controlCount,
+      mappingCount,
+      familyCount
+    };
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.controlMetadataCache.clear();
+    this.refreshControlsCache();
+  }
+};
+
+// cli/server/infrastructure/gitHistory.ts
+import * as fs2 from "fs";
+import * as git from "isomorphic-git";
+import { relative } from "path";
+
+// cli/server/infrastructure/yamlDiff.ts
+import * as yaml3 from "js-yaml";
+function createYamlDiff(oldYaml, newYaml, isArrayFile = false) {
+  try {
+    const emptyDefault = isArrayFile ? "[]" : "{}";
+    const oldData = yaml3.load(oldYaml || emptyDefault);
+    const newData = yaml3.load(newYaml || emptyDefault);
+    const changes = compareValues(oldData, newData, "");
+    return {
+      hasChanges: changes.length > 0,
+      changes,
+      summary: generateSummary(changes)
+    };
+  } catch (error) {
+    console.error("Error parsing YAML for diff:", error);
+    return {
+      hasChanges: false,
+      changes: [],
+      summary: "Error parsing YAML content"
+    };
+  }
+}
+function compareValues(oldValue, newValue, basePath) {
+  const changes = [];
+  if (oldValue === null || oldValue === void 0) {
+    if (newValue !== null && newValue !== void 0) {
+      changes.push({
+        type: "added",
+        path: basePath || "root",
+        newValue,
+        description: `Added ${basePath || "content"}`
+      });
+    }
+    return changes;
+  }
+  if (newValue === null || newValue === void 0) {
+    changes.push({
+      type: "removed",
+      path: basePath || "root",
+      oldValue,
+      description: `Removed ${basePath || "content"}`
+    });
+    return changes;
+  }
+  if (Array.isArray(oldValue) || Array.isArray(newValue)) {
+    return compareArrays(oldValue, newValue, basePath);
+  }
+  if (typeof oldValue === "object" && typeof newValue === "object") {
+    return compareObjects(oldValue, newValue, basePath);
+  }
+  if (oldValue !== newValue) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue,
+      newValue,
+      description: `Changed ${basePath || "value"}`
+    });
+  }
+  return changes;
+}
+function compareObjects(oldObj, newObj, basePath) {
+  const changes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+  for (const key of allKeys) {
+    const currentPath = basePath ? `${basePath}.${key}` : key;
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!(key in oldObj)) {
+      changes.push({
+        type: "added",
+        path: currentPath,
+        newValue,
+        description: `Added ${key}`
+      });
+    } else if (!(key in newObj)) {
+      changes.push({
+        type: "removed",
+        path: currentPath,
+        oldValue,
+        description: `Removed ${key}`
+      });
+    } else if (!deepEqual(oldValue, newValue)) {
+      if (typeof oldValue === "object" && typeof newValue === "object") {
+        changes.push(...compareValues(oldValue, newValue, currentPath));
+      } else {
+        changes.push({
+          type: "modified",
+          path: currentPath,
+          oldValue,
+          newValue,
+          description: `Changed ${key}`
+        });
+      }
+    }
+  }
+  return changes;
+}
+function compareArrays(oldArr, newArr, basePath) {
+  const changes = [];
+  if (!Array.isArray(oldArr) && Array.isArray(newArr)) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue: oldArr,
+      newValue: newArr,
+      description: `Changed ${basePath || "value"} from non-array to array`
+    });
+    return changes;
+  }
+  if (Array.isArray(oldArr) && !Array.isArray(newArr)) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue: oldArr,
+      newValue: newArr,
+      description: `Changed ${basePath || "value"} from array to non-array`
+    });
+    return changes;
+  }
+  const oldArray = oldArr;
+  const newArray = newArr;
+  if (isMappingArray(oldArray) || isMappingArray(newArray)) {
+    return compareMappingArrays(oldArray, newArray, basePath);
+  }
+  if (oldArray.length !== newArray.length) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue: oldArray,
+      newValue: newArray,
+      description: `Array ${basePath || "items"} changed from ${oldArray.length} to ${newArray.length} items`
+    });
+  } else {
+    for (let i = 0; i < oldArray.length; i++) {
+      const elementPath = `${basePath}[${i}]`;
+      if (!deepEqual(oldArray[i], newArray[i])) {
+        changes.push(...compareValues(oldArray[i], newArray[i], elementPath));
+      }
+    }
+  }
+  return changes;
+}
+function isMappingArray(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) return false;
+  const firstItem = arr[0];
+  return typeof firstItem === "object" && firstItem !== null && "control_id" in firstItem && "uuid" in firstItem;
+}
+function compareMappingArrays(oldArr, newArr, basePath) {
+  const changes = [];
+  const oldMappings = /* @__PURE__ */ new Map();
+  const newMappings = /* @__PURE__ */ new Map();
+  for (const item of oldArr) {
+    if (typeof item === "object" && item !== null && "uuid" in item) {
+      oldMappings.set(item.uuid, item);
+    }
+  }
+  for (const item of newArr) {
+    if (typeof item === "object" && item !== null && "uuid" in item) {
+      newMappings.set(item.uuid, item);
+    }
+  }
+  for (const [uuid, mapping] of newMappings) {
+    if (!oldMappings.has(uuid)) {
+      changes.push({
+        type: "added",
+        path: `mapping`,
+        newValue: mapping,
+        description: `Added mapping`
+      });
+    }
+  }
+  for (const [uuid, mapping] of oldMappings) {
+    if (!newMappings.has(uuid)) {
+      changes.push({
+        type: "removed",
+        path: `mapping`,
+        oldValue: mapping,
+        description: `Removed mapping`
+      });
+    }
+  }
+  for (const [uuid, oldMapping] of oldMappings) {
+    if (newMappings.has(uuid)) {
+      const newMapping = newMappings.get(uuid);
+      if (!deepEqual(oldMapping, newMapping)) {
+        changes.push({
+          type: "modified",
+          path: `mapping`,
+          oldValue: oldMapping,
+          newValue: newMapping,
+          description: `Modified mapping`
+        });
+      }
+    }
+  }
+  if (changes.length === 0 && oldArr.length !== newArr.length) {
+    changes.push({
+      type: "modified",
+      path: basePath || "mappings",
+      oldValue: oldArr,
+      newValue: newArr,
+      description: `Mappings changed from ${oldArr.length} to ${newArr.length} items`
+    });
+  }
+  return changes;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!bKeys.includes(key)) return false;
+      if (!deepEqual(aObj[key], bObj[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function generateSummary(changes) {
+  if (changes.length === 0) {
+    return "No changes detected";
+  }
+  const added = changes.filter((c) => c.type === "added").length;
+  const removed = changes.filter((c) => c.type === "removed").length;
+  const modified = changes.filter((c) => c.type === "modified").length;
+  const parts = [];
+  if (added > 0) parts.push(`${added} added`);
+  if (removed > 0) parts.push(`${removed} removed`);
+  if (modified > 0) parts.push(`${modified} modified`);
+  return parts.join(", ");
+}
+
+// cli/server/infrastructure/gitHistory.ts
+var GitHistoryUtil = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Check if the directory is a git repository
+   */
+  async isGitRepository() {
+    try {
+      const gitDir = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+      return !!gitDir;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get git history for a specific file
+   */
+  async getFileHistory(filePath, limit = 50) {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return {
+        filePath,
+        commits: [],
+        totalCommits: 0,
+        firstCommit: null,
+        lastCommit: null
+      };
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+      const relativePath = relative(gitRoot, filePath);
+      const commits = await git.log({
+        fs: fs2,
+        dir: gitRoot,
+        filepath: relativePath,
+        depth: limit
+      });
+      if (!commits || commits.length === 0) {
+        return {
+          filePath,
+          commits: [],
+          totalCommits: 0,
+          firstCommit: null,
+          lastCommit: null
+        };
+      }
+      const gitCommits = await this.convertIsomorphicCommits(commits, relativePath, gitRoot);
+      return {
+        filePath,
+        commits: gitCommits,
+        totalCommits: gitCommits.length,
+        firstCommit: gitCommits[gitCommits.length - 1] || null,
+        lastCommit: gitCommits[0] || null
+      };
+    } catch (error) {
+      const err = error;
+      if (err?.code === "NotFoundError" || err?.message?.includes("Could not find file")) {
+        return {
+          filePath,
+          commits: [],
+          totalCommits: 0,
+          firstCommit: null,
+          lastCommit: null
+        };
+      }
+      console.error(`Unexpected error getting git history for ${filePath}:`, error);
+      return {
+        filePath,
+        commits: [],
+        totalCommits: 0,
+        firstCommit: null,
+        lastCommit: null
+      };
+    }
+  }
+  /**
+   * Get the total number of commits for a file
+   */
+  async getFileCommitCount(filePath) {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return 0;
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+      const relativePath = relative(gitRoot, filePath);
+      const commits = await git.log({
+        fs: fs2,
+        dir: gitRoot,
+        filepath: relativePath
+      });
+      return commits.length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Get the latest commit info for a file
+   */
+  async getLatestCommit(filePath) {
+    const history = await this.getFileHistory(filePath, 1);
+    return history.lastCommit;
+  }
+  /**
+   * Get file content at a specific commit (public method)
+   */
+  async getFileContentAtCommit(filePath, commitHash) {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return null;
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+      const relativePath = relative(gitRoot, filePath);
+      return await this.getFileAtCommit(commitHash, relativePath, gitRoot);
+    } catch (error) {
+      console.error(`Error getting file content at commit ${commitHash}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Convert isomorphic-git commits to our GitCommit format
+   */
+  async convertIsomorphicCommits(commits, relativePath, gitRoot) {
+    const gitCommits = [];
+    for (let i = 0; i < commits.length; i++) {
+      const commit = commits[i];
+      const includeDiff = i < 5;
+      let changes = { insertions: 0, deletions: 0, files: 1 };
+      let diff;
+      let yamlDiff;
+      if (includeDiff) {
+        try {
+          const diffResult = await this.getCommitDiff(commit.oid, relativePath, gitRoot);
+          changes = diffResult.changes;
+          diff = diffResult.diff;
+          yamlDiff = diffResult.yamlDiff;
+        } catch (error) {
+        }
+      }
+      gitCommits.push({
+        hash: commit.oid,
+        shortHash: commit.oid.substring(0, 7),
+        author: commit.commit.author.name,
+        authorEmail: commit.commit.author.email,
+        date: new Date(commit.commit.author.timestamp * 1e3).toISOString(),
+        message: commit.commit.message,
+        changes,
+        ...diff && { diff },
+        ...yamlDiff && { yamlDiff }
+      });
+    }
+    return gitCommits;
+  }
+  /**
+   * Get diff for a specific commit and file
+   */
+  async getCommitDiff(commitOid, relativePath, gitRoot) {
+    try {
+      const commit = await git.readCommit({ fs: fs2, dir: gitRoot, oid: commitOid });
+      const parentOid = commit.commit.parent.length > 0 ? commit.commit.parent[0] : null;
+      if (!parentOid) {
+        const currentContent2 = await this.getFileAtCommit(commitOid, relativePath, gitRoot);
+        if (currentContent2) {
+          const lines = currentContent2.split("\n");
+          const isMappingFile2 = relativePath.includes("-mappings.yaml");
+          const yamlDiff2 = createYamlDiff("", currentContent2, isMappingFile2);
+          return {
+            changes: { insertions: lines.length, deletions: 0, files: 1 },
+            diff: `--- /dev/null
++++ b/${relativePath}
+@@ -0,0 +1,${lines.length} @@
+` + lines.map((line) => "+" + line).join("\n"),
+            yamlDiff: yamlDiff2
+          };
+        }
+        return { changes: { insertions: 0, deletions: 0, files: 1 } };
+      }
+      const currentContent = await this.getFileAtCommit(commitOid, relativePath, gitRoot);
+      const parentContent = await this.getFileAtCommit(parentOid, relativePath, gitRoot);
+      if (!currentContent && !parentContent) {
+        return { changes: { insertions: 0, deletions: 0, files: 1 } };
+      }
+      const currentLines = currentContent ? currentContent.split("\n") : [];
+      const parentLines = parentContent ? parentContent.split("\n") : [];
+      const diff = this.createSimpleDiff(parentLines, currentLines, relativePath);
+      const { insertions, deletions } = this.countChanges(parentLines, currentLines);
+      const isMappingFile = relativePath.includes("-mappings.yaml");
+      const yamlDiff = createYamlDiff(parentContent || "", currentContent || "", isMappingFile);
+      return {
+        changes: { insertions, deletions, files: 1 },
+        diff,
+        yamlDiff
+      };
+    } catch (error) {
+      return { changes: { insertions: 0, deletions: 0, files: 1 } };
+    }
+  }
+  /**
+   * Get file content at a specific commit
+   */
+  async getFileAtCommit(commitOid, filepath, gitRoot) {
+    try {
+      const { blob } = await git.readBlob({
+        fs: fs2,
+        dir: gitRoot,
+        oid: commitOid,
+        filepath
+      });
+      return new TextDecoder().decode(blob);
+    } catch (_error) {
+      return null;
+    }
+  }
+  /**
+   * Create a simple unified diff between two file versions
+   */
+  createSimpleDiff(oldLines, newLines, filepath) {
+    const diffLines = [];
+    diffLines.push(`--- a/${filepath}`);
+    diffLines.push(`+++ b/${filepath}`);
+    const oldCount = oldLines.length;
+    const newCount = newLines.length;
+    diffLines.push(`@@ -1,${oldCount} +1,${newCount} @@`);
+    let i = 0, j = 0;
+    while (i < oldLines.length || j < newLines.length) {
+      if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+        diffLines.push(` ${oldLines[i]}`);
+        i++;
+        j++;
+      } else if (i < oldLines.length && (j >= newLines.length || oldLines[i] !== newLines[j])) {
+        diffLines.push(`-${oldLines[i]}`);
+        i++;
+      } else if (j < newLines.length) {
+        diffLines.push(`+${newLines[j]}`);
+        j++;
+      }
+    }
+    return diffLines.join("\n");
+  }
+  /**
+   * Count insertions and deletions between two file versions
+   */
+  countChanges(oldLines, newLines) {
+    let insertions = 0;
+    let deletions = 0;
+    const maxLines = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLines; i++) {
+      const oldLine = i < oldLines.length ? oldLines[i] : null;
+      const newLine = i < newLines.length ? newLines[i] : null;
+      if (oldLine === null) {
+        insertions++;
+      } else if (newLine === null) {
+        deletions++;
+      } else if (oldLine !== newLine) {
+        insertions++;
+        deletions++;
+      }
+    }
+    return { insertions, deletions };
+  }
+  /**
+   * Get git stats for the entire repository
+   */
+  async getRepositoryStats() {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return {
+        totalCommits: 0,
+        contributors: 0,
+        lastCommitDate: null,
+        firstCommitDate: null
+      };
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+      const commits = await git.log({ fs: fs2, dir: gitRoot });
+      const contributorEmails = /* @__PURE__ */ new Set();
+      commits.forEach((commit) => {
+        contributorEmails.add(commit.commit.author.email);
+      });
+      const firstCommit = commits[commits.length - 1];
+      const lastCommit = commits[0];
+      return {
+        totalCommits: commits.length,
+        contributors: contributorEmails.size,
+        lastCommitDate: lastCommit ? new Date(lastCommit.commit.author.timestamp * 1e3).toISOString() : null,
+        firstCommitDate: firstCommit ? new Date(firstCommit.commit.author.timestamp * 1e3).toISOString() : null
+      };
+    } catch (error) {
+      console.error("Error getting repository stats:", error);
+      return {
+        totalCommits: 0,
+        contributors: 0,
+        lastCommitDate: null,
+        firstCommitDate: null
+      };
+    }
+  }
+};
+
+// cli/server/serverState.ts
+var serverState = void 0;
+function initializeServerState(controlSetDir, subdir = ".") {
+  const fullPath = subdir === "." ? controlSetDir : join3(controlSetDir, subdir);
+  serverState = {
+    CONTROL_SET_DIR: controlSetDir,
+    currentSubdir: subdir,
+    fileStore: new FileStore({ baseDir: fullPath }),
+    gitHistory: new GitHistoryUtil(fullPath),
+    controlsCache: /* @__PURE__ */ new Map(),
+    mappingsCache: /* @__PURE__ */ new Map(),
+    controlsByFamily: /* @__PURE__ */ new Map(),
+    mappingsByFamily: /* @__PURE__ */ new Map(),
+    mappingsByControl: /* @__PURE__ */ new Map()
+  };
+  return serverState;
+}
+function getServerState() {
+  if (!serverState) {
+    throw new Error("Server state not initialized. Call initializeServerState() first.");
+  }
+  return serverState;
+}
+function getCurrentControlSetPath() {
+  const state = getServerState();
+  return state.currentSubdir === "." ? state.CONTROL_SET_DIR : join3(state.CONTROL_SET_DIR, state.currentSubdir);
+}
+function addControlToIndexes(control) {
+  const state = getServerState();
+  const family = control.family;
+  if (!family) {
+    return;
+  }
+  if (!state.controlsByFamily.has(family)) {
+    state.controlsByFamily.set(family, /* @__PURE__ */ new Set());
+  }
+  state.controlsByFamily.get(family).add(control.id);
+}
+function addMappingToIndexes(mapping) {
+  const state = getServerState();
+  const family = mapping.control_id.split("-")[0];
+  if (!state.mappingsByFamily.has(family)) {
+    state.mappingsByFamily.set(family, /* @__PURE__ */ new Set());
+  }
+  state.mappingsByFamily.get(family).add(mapping.uuid);
+  if (!state.mappingsByControl.has(mapping.control_id)) {
+    state.mappingsByControl.set(mapping.control_id, /* @__PURE__ */ new Set());
+  }
+  state.mappingsByControl.get(mapping.control_id).add(mapping.uuid);
+}
+async function loadAllData() {
+  const state = getServerState();
+  debug("Loading data into memory...");
+  try {
+    const controls = await state.fileStore.loadAllControls();
+    for (const control of controls) {
+      state.controlsCache.set(control.id, control);
+      addControlToIndexes(control);
+    }
+    debug(`Loaded ${controls.length} controls from individual files`);
+    const mappings = await state.fileStore.loadMappings();
+    for (const mapping of mappings) {
+      state.mappingsCache.set(mapping.uuid, mapping);
+      addMappingToIndexes(mapping);
+    }
+    debug(`Loaded ${mappings.length} mappings`);
+  } catch (error) {
+    console.error("Error loading data:", error);
+  }
+}
+async function saveMappingsToFile() {
+  const state = getServerState();
+  try {
+    const allMappings = Array.from(state.mappingsCache.values());
+    await state.fileStore.saveMappings(allMappings);
+    debug(`Saved ${allMappings.length} mappings`);
+  } catch (error) {
+    console.error("Error saving mappings:", error);
+  }
+}
+export {
+  addControlToIndexes,
+  addMappingToIndexes,
+  getCurrentControlSetPath,
+  getServerState,
+  initializeServerState,
+  loadAllData,
+  saveMappingsToFile
+};