brch 0.0.1 → 0.0.3

package/dist/index.js

@@ -2338,7 +2338,8 @@ var {
 } = import__.default;
 
 // src/services/configService.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
+import { readFile, writeFile, access, mkdir } from "fs/promises";
+import { constants } from "fs";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -2835,103 +2836,185 @@ var import_ini = __toESM(require_ini(), 1);
 // src/utils/constants.ts
 import { homedir } from "os";
 var VCS_NAME = "brch";
-var VCS_CONFIG = ".brchconfig";
-var HOME_DIR = homedir();
-var GLOBAL_CONFIG_PATH = `${HOME_DIR}/${VCS_CONFIG}`;
 var VCS_DIR = ".brch";
-var OBJECT_DIR = `${VCS_DIR}/objects`;
-var HEAD_FILE = `${VCS_DIR}/HEAD`;
+var VCS_PATH = `${process.cwd()}/${VCS_DIR}`;
+var OBJECTS_PATH = `${VCS_DIR}/objects`;
+var REFS_PATH = `${VCS_DIR}/refs`;
+var REFS_HEAD_PATH = `${REFS_PATH}/heads`;
+var HEAD_PATH = `${VCS_DIR}/HEAD`;
+var GLOBAL_CONFIG_FILE = ".brchconfig";
+var HOME_DIR = homedir();
+var GLOBAL_CONFIG_PATH = `${HOME_DIR}/${GLOBAL_CONFIG_FILE}`;
+var LOCAL_CONFIG_FILE = "config";
+var LOCAL_CONFIG_PATH = `${process.cwd()}/${VCS_DIR}/${LOCAL_CONFIG_FILE}`;
+var INDEX_FILE = "index.json";
+var INDEX_PATH = `${process.cwd()}/${VCS_DIR}/${INDEX_FILE}`;
+var IGNORE_FILE = ".brchignore";
+var IGNORE_PATH = `${process.cwd()}/${IGNORE_FILE}`;
 
 // src/services/configService.ts
+import { dirname } from "path";
 var setConfig = async ({ scopeKey, value, isGlobal }) => {
-  const configPath = isGlobal ? GLOBAL_CONFIG_PATH : VCS_CONFIG;
-  if (!existsSync(configPath)) {
-    writeFileSync(configPath, "");
-  }
-  const configFileContent = readConfigFile({ isGlobal });
-  const configFileJson = import_ini.parse(configFileContent || "");
-  const scopeKeyAttrs = scopeKey.split(".");
-  const scope = scopeKeyAttrs[0];
-  const key = scopeKeyAttrs[1];
-  if (!configFileJson[scope]) {
-    configFileJson[scope] = {};
-  }
-  configFileJson[scope][key] = value;
-  const configFileString = import_ini.stringify(configFileJson);
-  writeFileSync(configPath, configFileString);
-  console.log(source_default.green("Configuration set successfully."));
-};
-var readConfigFile = ({ isGlobal }) => {
-  return readFileSync(isGlobal ? GLOBAL_CONFIG_PATH : VCS_CONFIG, {
-    encoding: "utf-8"
-  });
+  try {
+    const configPath = isGlobal ? GLOBAL_CONFIG_PATH : LOCAL_CONFIG_PATH;
+    if (!isGlobal) {
+      try {
+        await access(VCS_DIR, constants.F_OK);
+      } catch {
+        console.log(source_default.red("No local configuration file found. Run `brch config set --global <scopeKey> <value>` to set global configuration or run `brch init` to initialize a new repository."));
+        process.exit(1);
+      }
+    }
+    try {
+      await access(configPath, constants.F_OK);
+    } catch {
+      await mkdir(dirname(configPath), { recursive: true });
+      await writeFile(configPath, "");
+    }
+    const configFileContent = await readConfigFile({ isGlobal });
+    const configFileJson = import_ini.parse(configFileContent || "");
+    const scopeKeyAttrs = scopeKey.split(".");
+    const scope = scopeKeyAttrs[0];
+    const key = scopeKeyAttrs[1];
+    if (!configFileJson[scope]) {
+      configFileJson[scope] = {};
+    }
+    configFileJson[scope][key] = value;
+    const configFileString = import_ini.stringify(configFileJson);
+    await writeFile(configPath, configFileString);
+    console.log(source_default.green("Configuration set successfully."));
+  } catch (error) {
+    console.error(source_default.red(`Failed to set configuration: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+};
+var readConfigFile = async ({ isGlobal }) => {
+  try {
+    return await readFile(isGlobal ? GLOBAL_CONFIG_PATH : LOCAL_CONFIG_PATH, {
+      encoding: "utf-8"
+    });
+  } catch (error) {
+    console.error(source_default.red(`Failed to read config file: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
 };
 
 // src/commands/configCommand.ts
-var configCommand = new Command("config").description("Manage repository or global configuration").option("--global", "Set global configuration").addCommand(new Command("set").argument("<scopeKey>", "Configuration key (e.g. user.name)").argument("<value>", "Configuration value").description("Set a configuration value").action(async function(scopeKey, value) {
+var configCommand = new Command("config").description("Manage repository or global configuration settings").option("--global", "Set global configuration (applies to all repositories)").addHelpText("after", `
+Examples:
+  $ brch config set user.name "John Doe"              Set local config
+  $ brch config set user.email "john@example.com" --global  Set global config
+
+Configuration is stored in:
+  - Local: .brch/config (repository-specific)
+  - Global: ~/.brchconfig (applies to all repositories)
+
+Common configuration keys:
+  - user.name: Your name
+  - user.email: Your email address
+`).addCommand(new Command("set").argument("<scopeKey>", "Configuration key (e.g. user.name)").argument("<value>", "Configuration value").description("Set a configuration value").addHelpText("after", `
+Examples:
+  $ brch config set user.name "John Doe"
+  $ brch config set user.email "john@example.com" --global
+`).action(async function(scopeKey, value) {
   await setConfig({ scopeKey, value, isGlobal: this.parent?.opts().global ?? false });
 }));
 
 // src/services/initService.ts
-import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 var initRepo = async () => {
   try {
-    mkdirSync(VCS_DIR);
-    mkdirSync(OBJECT_DIR);
-    writeFileSync2(HEAD_FILE, "ref: refs/heads/master");
-    console.log("Initialized empty " + source_default.green("dlt") + " repository in " + source_default.green(process.cwd() + "/" + VCS_DIR));
+    await mkdir2(VCS_DIR, { recursive: true });
+    await mkdir2(OBJECTS_PATH, { recursive: true });
+    await mkdir2(REFS_PATH, { recursive: true });
+    await mkdir2(REFS_PATH + "/heads", { recursive: true });
+    await writeFile2(HEAD_PATH, "ref: refs/heads/master");
+    console.log("Initialized empty " + source_default.green("brch") + " repository in " + source_default.green(process.cwd() + "/" + VCS_DIR));
   } catch (error) {
     if (error.code === "EEXIST") {
-      console.log(source_default.red("dlt repository already initialized."));
-      return;
+      console.log(source_default.red("brch repository already initialized."));
     }
     console.error("Error initializing repository:", error);
+    process.exit(1);
   }
 };
 
 // src/commands/initCommand.ts
-var initCommand = new Command("init").description("Initialize a new repository").action(async () => {
-  initRepo();
-});
+var initCommand = new Command("init").description("Initialize a new brch repository in the current directory").addHelpText("after", `
+Examples:
+  $ brch init
+
+This command creates a .brch directory with the necessary structure for version control.
+The repository will track changes in the current directory and its subdirectories.
+`).action(initRepo);
+
+// src/services/addService.ts
+import { mkdir as mkdir3, readdir, readFile as readFile2, stat, writeFile as writeFile3, access as access2 } from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import { join as join2, relative, resolve, sep } from "node:path";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+var hashContent = (content) => {
+  const hash = createHash("sha1");
+  if (typeof content === "string") {
+    hash.update(content, "utf-8");
+  } else {
+    hash.update(content);
+  }
+  return hash.digest("hex");
+};
+
+// src/utils/objectPath.ts
+import { join } from "node:path";
+var getObjectPath = (hash, objectsDir) => {
+  const objectDir = join(objectsDir, hash.slice(0, 2));
+  const objectPath = join(objectDir, hash.slice(2));
+  return { objectDir, objectPath };
+};
 
 // src/services/addService.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync2 } from "node:fs";
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { join, relative, resolve, sep } from "node:path";
-var INDEX_FILE = "index.json";
 var addFiles = async (paths) => {
   const repoRoot = process.cwd();
-  const brchPath = join(repoRoot, VCS_DIR);
-  if (!existsSync2(brchPath)) {
+  try {
+    await access2(VCS_PATH, constants2.F_OK);
+  } catch {
     throw new Error("Not a brch repository (or any of the parent directories). Run `brch init` first.");
   }
-  const objectDir = join(repoRoot, OBJECT_DIR);
-  await mkdir(objectDir, { recursive: true });
-  const { filesToStage, missing } = await collectFiles(paths, repoRoot);
-  const indexPath = join(brchPath, INDEX_FILE);
-  const indexEntries = await readIndex(indexPath);
+  const objectsDir = join2(repoRoot, OBJECTS_PATH);
+  await mkdir3(objectsDir, { recursive: true });
+  const ignorePatterns = await loadIgnorePatterns(repoRoot);
+  const { filesToStage, missing } = await collectFiles(paths, repoRoot, ignorePatterns);
+  const indexEntries = await readIndex(INDEX_PATH);
   const staged = [];
   const skipped = [...missing];
   for (const absPath of filesToStage) {
     const relPath = normalizeRelativePath(relative(repoRoot, absPath));
-    const fileBuffer = await readFile(absPath);
-    const hash = createHash("sha1").update(fileBuffer).digest("hex");
-    const objectPath = join(objectDir, hash);
-    if (!existsSync2(objectPath)) {
-      await writeFile(objectPath, fileBuffer);
+    const fileBuffer = await readFile2(absPath);
+    const hash = hashContent(fileBuffer);
+    const { objectDir, objectPath } = getObjectPath(hash, objectsDir);
+    try {
+      await access2(objectPath, constants2.F_OK);
+    } catch {
+      await mkdir3(objectDir, { recursive: true });
+      await writeFile3(objectPath, fileBuffer);
     }
-    if (indexEntries[relPath] === hash) {
+    const existingEntry = indexEntries.find((entry) => entry.path === relPath);
+    if (existingEntry && existingEntry.hash === hash) {
       skipped.push(relPath);
       continue;
     }
-    indexEntries[relPath] = hash;
+    if (existingEntry) {
+      existingEntry.hash = hash;
+    } else {
+      indexEntries.push({ path: relPath, hash });
+    }
     staged.push(relPath);
   }
-  await writeFile(indexPath, JSON.stringify(indexEntries, null, 2));
+  await writeFile3(INDEX_PATH, JSON.stringify(indexEntries, null, 2));
   return { staged, skipped };
 };
-var collectFiles = async (targets, repoRoot) => {
+var collectFiles = async (targets, repoRoot, ignorePatterns) => {
   const filesToStage = new Set;
   const missing = [];
   for (const target of targets) {
@@ -2943,9 +3026,11 @@ var collectFiles = async (targets, repoRoot) => {
     try {
       const targetStat = await stat(absTargetPath);
       if (targetStat.isDirectory()) {
-        await walkDirectory(absTargetPath, repoRoot, filesToStage);
+        await walkDirectory(absTargetPath, repoRoot, filesToStage, ignorePatterns);
       } else if (targetStat.isFile()) {
-        filesToStage.add(absTargetPath);
+        if (!matchesIgnorePattern(absTargetPath, repoRoot, ignorePatterns)) {
+          filesToStage.add(absTargetPath);
+        }
       }
     } catch (error) {
       missing.push(target);
@@ -2953,26 +3038,107 @@ var collectFiles = async (targets, repoRoot) => {
   }
   return { filesToStage, missing };
 };
-var walkDirectory = async (dir, repoRoot, collector) => {
+var walkDirectory = async (dir, repoRoot, collector, ignorePatterns) => {
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const entryPath = join(dir, entry.name);
-    if (shouldIgnore(entryPath, repoRoot)) {
+    const entryPath = join2(dir, entry.name);
+    if (shouldIgnore(entryPath, repoRoot, ignorePatterns)) {
       continue;
     }
     if (entry.isDirectory()) {
-      await walkDirectory(entryPath, repoRoot, collector);
+      await walkDirectory(entryPath, repoRoot, collector, ignorePatterns);
     } else if (entry.isFile()) {
-      collector.add(entryPath);
+      if (!matchesIgnorePattern(entryPath, repoRoot, ignorePatterns)) {
+        collector.add(entryPath);
+      }
+    }
+  }
+};
+var loadIgnorePatterns = async (repoRoot) => {
+  const ignorePath = join2(repoRoot, IGNORE_FILE);
+  try {
+    await access2(ignorePath, constants2.F_OK);
+  } catch {
+    return [];
+  }
+  try {
+    const content = await readFile2(ignorePath, "utf-8");
+    const patterns = [];
+    for (const line of content.split(`
+`)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const negated = trimmed.startsWith("!");
+      const pattern = negated ? trimmed.slice(1) : trimmed;
+      const isDirectory = pattern.endsWith("/");
+      const normalizedPattern = isDirectory ? pattern.slice(0, -1) : pattern;
+      patterns.push({
+        pattern: normalizedPattern,
+        negated,
+        isDirectory
+      });
+    }
+    return patterns;
+  } catch (error) {
+    return [];
+  }
+};
+var matchesIgnorePattern = (absPath, repoRoot, patterns) => {
+  const relPath = normalizeRelativePath(relative(repoRoot, absPath));
+  if (relPath === "") {
+    return false;
+  }
+  let matched = false;
+  let matchedNegated = false;
+  for (const { pattern, negated, isDirectory } of patterns) {
+    if (matchesPattern(relPath, pattern, isDirectory)) {
+      if (negated) {
+        matchedNegated = true;
+      } else {
+        matched = true;
+      }
+    }
+  }
+  return matched && !matchedNegated;
+};
+var matchesPattern = (relPath, pattern, isDirectoryPattern) => {
+  let regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLE_STAR___").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/___DOUBLE_STAR___/g, ".*");
+  if (pattern.startsWith("/")) {
+    regexPattern = "^" + regexPattern.slice(1);
+  } else {
+    regexPattern = "(^|/)" + regexPattern;
+  }
+  if (isDirectoryPattern) {
+    regexPattern = regexPattern + "/";
+    const regex = new RegExp(regexPattern);
+    if (regex.test(relPath + "/")) {
+      return true;
+    }
+    const pathParts = relPath.split("/");
+    for (let i = 1;i <= pathParts.length; i++) {
+      const subPath = pathParts.slice(0, i).join("/");
+      if (regex.test(subPath + "/")) {
+        return true;
+      }
     }
+    return false;
+  } else {
+    regexPattern = regexPattern + "$";
+    const regex = new RegExp(regexPattern);
+    return regex.test(relPath);
   }
 };
-var shouldIgnore = (absPath, repoRoot) => {
+var shouldIgnore = (absPath, repoRoot, ignorePatterns) => {
   const relPath = normalizeRelativePath(relative(repoRoot, absPath));
   if (relPath === "") {
     return false;
   }
-  return relPath === VCS_DIR || relPath.startsWith(`${VCS_DIR}/`);
+  if (relPath === VCS_DIR || relPath.startsWith(`${VCS_DIR}/`) || relPath === `./${VCS_DIR}` || relPath.startsWith(`./${VCS_DIR}/`)) {
+    return true;
+  }
+  return matchesIgnorePattern(absPath, repoRoot, ignorePatterns);
 };
 var isWithinRepo = (absPath, repoRoot) => {
   const relPath = relative(repoRoot, absPath);
@@ -2982,30 +3148,60 @@ var isWithinRepo = (absPath, repoRoot) => {
   return !relPath.startsWith("..") && !relPath.includes(`..${sep}`);
 };
 var normalizeRelativePath = (pathValue) => {
-  return pathValue.split("\\").join("/");
+  const normalized = pathValue.split("\\").join("/");
+  if (normalized && !normalized.startsWith("./") && !normalized.startsWith("../") && !normalized.startsWith("/")) {
+    return "./" + normalized;
+  }
+  return normalized;
 };
 var readIndex = async (indexPath) => {
   try {
-    const content = await readFile(indexPath, "utf-8");
-    return content ? JSON.parse(content) : {};
+    const content = await readFile2(indexPath, "utf-8");
+    if (!content) {
+      return [];
+    }
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+      return parsed.map((entry) => ({
+        ...entry,
+        path: normalizeRelativePath(entry.path)
+      }));
+    } else if (typeof parsed === "object" && parsed !== null) {
+      return Object.entries(parsed).map(([path, hash]) => ({
+        path: normalizeRelativePath(path),
+        hash
+      }));
+    }
+    return [];
   } catch (error) {
-    return {};
+    return [];
   }
 };
 
 // src/commands/addCommand.ts
-var addCommand = new Command("add").argument("<paths...>", 'Files or directories to add to staging (supports "." for current directory)').description("Add files to the staging area").action(async (paths) => {
+var addCommand = new Command("add").argument("<paths...>", 'Files or directories to add to staging (supports "." for current directory)').description("Add files to the staging area for the next commit").addHelpText("after", `
+Examples:
+  $ brch add file.txt              Stage a single file
+  $ brch add src/                  Stage all files in src directory
+  $ brch add .                     Stage all files in current directory
+  $ brch add file1.txt file2.js    Stage multiple files
+
+The add command stages files for commit. Files that haven't changed since the last
+commit will be skipped. Only files that exist and have been modified will be staged.
+`).action(async (paths) => {
   const targets = paths;
   try {
     const { staged, skipped } = await addFiles(targets);
     if (staged.length > 0) {
       console.log(source_default.green("Staged:"));
-      staged.forEach((path) => console.log(`  ${path}`));
+      staged.forEach((path) => console.log(source_default.green(" - ") + path));
     }
+    console.log();
     if (skipped.length > 0) {
       console.log(source_default.yellow("Skipped (unchanged or not found):"));
-      skipped.forEach((path) => console.log(`  ${path}`));
+      skipped.forEach((path) => console.log(source_default.yellow(" - ") + path));
     }
+    console.log();
     if (staged.length === 0 && skipped.length === 0) {
       console.log(source_default.yellow("Nothing to add."));
     }
@@ -3015,14 +3211,2795 @@ var addCommand = new Command("add").argument("<paths...>", 'Files or directories
   }
 });
 
-// src/commands/index.ts
-var registerCommands = (program2) => {
-  program2.addCommand(configCommand);
-  program2.addCommand(initCommand);
-  program2.addCommand(addCommand);
+// src/services/commitService.ts
+import fs2 from "fs/promises";
+var import_ini2 = __toESM(require_ini(), 1);
+import path2 from "path";
+import { writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+
+// src/utils/head.ts
+import fs from "fs/promises";
+import path from "path";
+var getCurrentBranchName = async () => {
+  try {
+    const headContent = await fs.readFile(HEAD_PATH, "utf-8");
+    const headContentTrimmed = headContent.trim();
+    if (headContentTrimmed.startsWith("ref: ")) {
+      const refPath = headContentTrimmed.substring(5).trim();
+      return refPath.replace("refs/heads/", "");
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+var getCurrentHead = async () => {
+  try {
+    const headContent = await fs.readFile(HEAD_PATH, "utf-8");
+    const headContentTrimmed = headContent.trim();
+    if (headContentTrimmed.startsWith("ref: ")) {
+      const refPath = headContentTrimmed.substring(5).trim();
+      const branchName = refPath.replace("refs/heads/", "");
+      const branchRefPath = path.join(process.cwd(), REFS_HEAD_PATH, branchName);
+      try {
+        const commitHash = await fs.readFile(branchRefPath, "utf-8");
+        return commitHash.trim();
+      } catch (error) {
+        return null;
+      }
+    }
+    return headContentTrimmed;
+  } catch (error) {
+    return null;
+  }
 };
 
-// src/index.ts
-program.name(VCS_NAME).description("A simple VCS").version("0.0.1");
+// src/services/commitService.ts
+var commitChanges = async (message) => {
+  try {
+    const userData = await getUserData();
+    const indexEntries = await readIndex2(INDEX_PATH);
+    const parentCommit = await getCurrentHead();
+    let branchName = await getCurrentBranchName();
+    const commitData = {
+      timeStamp: new Date().toISOString(),
+      message,
+      files: indexEntries,
+      parent: parentCommit || "",
+      author: {
+        name: userData.user.name,
+        email: userData.user.email
+      }
+    };
+    const commitHash = hashContent(JSON.stringify(commitData));
+    const repoRoot = process.cwd();
+    const objectsDir = path2.join(repoRoot, OBJECTS_PATH);
+    const { objectDir, objectPath } = getObjectPath(commitHash, objectsDir);
+    await mkdir4(objectDir, { recursive: true });
+    await writeFile4(objectPath, JSON.stringify(commitData));
+    if (!branchName) {
+      branchName = "master";
+      await writeFile4(HEAD_PATH, `ref: refs/heads/${branchName}`);
+    }
+    const branchRefPath = path2.join(repoRoot, REFS_HEAD_PATH, branchName);
+    await mkdir4(path2.dirname(branchRefPath), { recursive: true });
+    await writeFile4(branchRefPath, commitHash);
+    console.log(`Commit successfully created: ${commitHash}`);
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.log(source_default.red("Error creating commit:"), message2);
+    process.exit(1);
+  }
+};
+var normalizeRelativePath2 = (pathValue) => {
+  const normalized = pathValue.split("\\").join("/");
+  if (normalized && !normalized.startsWith("./") && !normalized.startsWith("../") && !normalized.startsWith("/")) {
+    return "./" + normalized;
+  }
+  return normalized;
+};
+var readIndex2 = async (indexPath) => {
+  try {
+    const content = await fs2.readFile(indexPath, "utf-8");
+    if (!content) {
+      return [];
+    }
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+      return parsed.map((entry) => ({
+        ...entry,
+        path: normalizeRelativePath2(entry.path)
+      }));
+    } else if (typeof parsed === "object" && parsed !== null) {
+      return Object.entries(parsed).map(([path3, hash]) => ({
+        path: normalizeRelativePath2(path3),
+        hash
+      }));
+    }
+    return [];
+  } catch (error) {
+    return [];
+  }
+};
+var getUserData = async () => {
+  const readConfigFile2 = async (configPath) => {
+    try {
+      const configData = await fs2.readFile(configPath, "utf-8");
+      return import_ini2.parse(configData);
+    } catch (error) {
+      return null;
+    }
+  };
+  const localConfig = await readConfigFile2(LOCAL_CONFIG_PATH);
+  if (localConfig) {
+    return localConfig;
+  }
+  const globalConfig = await readConfigFile2(GLOBAL_CONFIG_PATH);
+  if (globalConfig) {
+    return globalConfig;
+  }
+  throw new Error("No config file found");
+};
+
+// src/commands/commitCommand.ts
+var commitCommand = new Command("commit").description("Commit staged changes to the repository").option("-m, --message <message>", "Commit message describing the changes").addHelpText("after", `
+Examples:
+  $ brch commit -m "Add new feature"     Commit with a message
+  $ brch commit --message "Fix bug"      Commit with a message (alternative syntax)
+
+The commit command creates a new commit with all currently staged files. You must
+provide a commit message using the -m or --message option. Only staged files will
+be included in the commit.
+`).action(async (options) => {
+  commitChanges(options.message);
+});
+
+// src/services/logService.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// node_modules/date-fns/constants.js
+var daysInYear = 365.2425;
+var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000;
+var minTime = -maxTime;
+var millisecondsInWeek = 604800000;
+var millisecondsInDay = 86400000;
+var secondsInHour = 3600;
+var secondsInDay = secondsInHour * 24;
+var secondsInWeek = secondsInDay * 7;
+var secondsInYear = secondsInDay * daysInYear;
+var secondsInMonth = secondsInYear / 12;
+var secondsInQuarter = secondsInMonth * 3;
+var constructFromSymbol = Symbol.for("constructDateFrom");
+
+// node_modules/date-fns/constructFrom.js
+function constructFrom(date, value) {
+  if (typeof date === "function")
+    return date(value);
+  if (date && typeof date === "object" && constructFromSymbol in date)
+    return date[constructFromSymbol](value);
+  if (date instanceof Date)
+    return new date.constructor(value);
+  return new Date(value);
+}
+
+// node_modules/date-fns/toDate.js
+function toDate(argument, context) {
+  return constructFrom(context || argument, argument);
+}
+
+// node_modules/date-fns/_lib/defaultOptions.js
+var defaultOptions = {};
+function getDefaultOptions() {
+  return defaultOptions;
+}
+
+// node_modules/date-fns/startOfWeek.js
+function startOfWeek(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const _date = toDate(date, options?.in);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  _date.setDate(_date.getDate() - diff);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+
+// node_modules/date-fns/startOfISOWeek.js
+function startOfISOWeek(date, options) {
+  return startOfWeek(date, { ...options, weekStartsOn: 1 });
+}
+
+// node_modules/date-fns/getISOWeekYear.js
+function getISOWeekYear(date, options) {
+  const _date = toDate(date, options?.in);
+  const year = _date.getFullYear();
+  const fourthOfJanuaryOfNextYear = constructFrom(_date, 0);
+  fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
+  fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
+  const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
+  const fourthOfJanuaryOfThisYear = constructFrom(_date, 0);
+  fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
+  fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
+  const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
+  if (_date.getTime() >= startOfNextYear.getTime()) {
+    return year + 1;
+  } else if (_date.getTime() >= startOfThisYear.getTime()) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+
+// node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js
+function getTimezoneOffsetInMilliseconds(date) {
+  const _date = toDate(date);
+  const utcDate = new Date(Date.UTC(_date.getFullYear(), _date.getMonth(), _date.getDate(), _date.getHours(), _date.getMinutes(), _date.getSeconds(), _date.getMilliseconds()));
+  utcDate.setUTCFullYear(_date.getFullYear());
+  return +date - +utcDate;
+}
+
+// node_modules/date-fns/_lib/normalizeDates.js
+function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(null, context || dates.find((date) => typeof date === "object"));
+  return dates.map(normalize);
+}
+
+// node_modules/date-fns/startOfDay.js
+function startOfDay(date, options) {
+  const _date = toDate(date, options?.in);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+
+// node_modules/date-fns/differenceInCalendarDays.js
+function differenceInCalendarDays(laterDate, earlierDate, options) {
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+  const laterStartOfDay = startOfDay(laterDate_);
+  const earlierStartOfDay = startOfDay(earlierDate_);
+  const laterTimestamp = +laterStartOfDay - getTimezoneOffsetInMilliseconds(laterStartOfDay);
+  const earlierTimestamp = +earlierStartOfDay - getTimezoneOffsetInMilliseconds(earlierStartOfDay);
+  return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInDay);
+}
+
+// node_modules/date-fns/startOfISOWeekYear.js
+function startOfISOWeekYear(date, options) {
+  const year = getISOWeekYear(date, options);
+  const fourthOfJanuary = constructFrom(options?.in || date, 0);
+  fourthOfJanuary.setFullYear(year, 0, 4);
+  fourthOfJanuary.setHours(0, 0, 0, 0);
+  return startOfISOWeek(fourthOfJanuary);
+}
+
+// node_modules/date-fns/isDate.js
+function isDate(value) {
+  return value instanceof Date || typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]";
+}
+
+// node_modules/date-fns/isValid.js
+function isValid(date) {
+  return !(!isDate(date) && typeof date !== "number" || isNaN(+toDate(date)));
+}
+
+// node_modules/date-fns/startOfYear.js
+function startOfYear(date, options) {
+  const date_ = toDate(date, options?.in);
+  date_.setFullYear(date_.getFullYear(), 0, 1);
+  date_.setHours(0, 0, 0, 0);
+  return date_;
+}
+
+// node_modules/date-fns/locale/en-US/_lib/formatDistance.js
+var formatDistanceLocale = {
+  lessThanXSeconds: {
+    one: "less than a second",
+    other: "less than {{count}} seconds"
+  },
+  xSeconds: {
+    one: "1 second",
+    other: "{{count}} seconds"
+  },
+  halfAMinute: "half a minute",
+  lessThanXMinutes: {
+    one: "less than a minute",
+    other: "less than {{count}} minutes"
+  },
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes"
+  },
+  aboutXHours: {
+    one: "about 1 hour",
+    other: "about {{count}} hours"
+  },
+  xHours: {
+    one: "1 hour",
+    other: "{{count}} hours"
+  },
+  xDays: {
+    one: "1 day",
+    other: "{{count}} days"
+  },
+  aboutXWeeks: {
+    one: "about 1 week",
+    other: "about {{count}} weeks"
+  },
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weeks"
+  },
+  aboutXMonths: {
+    one: "about 1 month",
+    other: "about {{count}} months"
+  },
+  xMonths: {
+    one: "1 month",
+    other: "{{count}} months"
+  },
+  aboutXYears: {
+    one: "about 1 year",
+    other: "about {{count}} years"
+  },
+  xYears: {
+    one: "1 year",
+    other: "{{count}} years"
+  },
+  overXYears: {
+    one: "over 1 year",
+    other: "over {{count}} years"
+  },
+  almostXYears: {
+    one: "almost 1 year",
+    other: "almost {{count}} years"
+  }
+};
+var formatDistance = (token, count, options) => {
+  let result;
+  const tokenValue = formatDistanceLocale[token];
+  if (typeof tokenValue === "string") {
+    result = tokenValue;
+  } else if (count === 1) {
+    result = tokenValue.one;
+  } else {
+    result = tokenValue.other.replace("{{count}}", count.toString());
+  }
+  if (options?.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "in " + result;
+    } else {
+      return result + " ago";
+    }
+  }
+  return result;
+};
+
+// node_modules/date-fns/locale/_lib/buildFormatLongFn.js
+function buildFormatLongFn(args) {
+  return (options = {}) => {
+    const width = options.width ? String(options.width) : args.defaultWidth;
+    const format = args.formats[width] || args.formats[args.defaultWidth];
+    return format;
+  };
+}
+
+// node_modules/date-fns/locale/en-US/_lib/formatLong.js
+var dateFormats = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+};
+var timeFormats = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+};
+var dateTimeFormats = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+};
+var formatLong = {
+  date: buildFormatLongFn({
+    formats: dateFormats,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats,
+    defaultWidth: "full"
+  })
+};
+
+// node_modules/date-fns/locale/en-US/_lib/formatRelative.js
+var formatRelativeLocale = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+};
+var formatRelative = (token, _date, _baseDate, _options) => formatRelativeLocale[token];
+
+// node_modules/date-fns/locale/_lib/buildLocalizeFn.js
+function buildLocalizeFn(args) {
+  return (value, options) => {
+    const context = options?.context ? String(options.context) : "standalone";
+    let valuesArray;
+    if (context === "formatting" && args.formattingValues) {
+      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      const width = options?.width ? String(options.width) : defaultWidth;
+      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+    } else {
+      const defaultWidth = args.defaultWidth;
+      const width = options?.width ? String(options.width) : args.defaultWidth;
+      valuesArray = args.values[width] || args.values[defaultWidth];
+    }
+    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+    return valuesArray[index];
+  };
+}
+
+// node_modules/date-fns/locale/en-US/_lib/localize.js
+var eraValues = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+};
+var quarterValues = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+};
+var monthValues = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ],
+  wide: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ]
+};
+var dayValues = {
+  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  wide: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ]
+};
+var dayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  }
+};
+var formattingDayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  }
+};
+var ordinalNumber = (dirtyNumber, _options) => {
+  const number = Number(dirtyNumber);
+  const rem100 = number % 100;
+  if (rem100 > 20 || rem100 < 10) {
+    switch (rem100 % 10) {
+      case 1:
+        return number + "st";
+      case 2:
+        return number + "nd";
+      case 3:
+        return number + "rd";
+    }
+  }
+  return number + "th";
+};
+var localize = {
+  ordinalNumber,
+  era: buildLocalizeFn({
+    values: eraValues,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues,
+    defaultWidth: "wide",
+    argumentCallback: (quarter) => quarter - 1
+  }),
+  month: buildLocalizeFn({
+    values: monthValues,
+    defaultWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues,
+    defaultWidth: "wide",
+    formattingValues: formattingDayPeriodValues,
+    defaultFormattingWidth: "wide"
+  })
+};
+
+// node_modules/date-fns/locale/_lib/buildMatchFn.js
+function buildMatchFn(args) {
+  return (string, options = {}) => {
+    const width = options.width;
+    const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+    const matchResult = string.match(matchPattern);
+    if (!matchResult) {
+      return null;
+    }
+    const matchedString = matchResult[0];
+    const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+    const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : findKey(parsePatterns, (pattern) => pattern.test(matchedString));
+    let value;
+    value = args.valueCallback ? args.valueCallback(key) : key;
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+function findKey(object, predicate) {
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
+      return key;
+    }
+  }
+  return;
+}
+function findIndex(array, predicate) {
+  for (let key = 0;key < array.length; key++) {
+    if (predicate(array[key])) {
+      return key;
+    }
+  }
+  return;
+}
+
+// node_modules/date-fns/locale/_lib/buildMatchPatternFn.js
+function buildMatchPatternFn(args) {
+  return (string, options = {}) => {
+    const matchResult = string.match(args.matchPattern);
+    if (!matchResult)
+      return null;
+    const matchedString = matchResult[0];
+    const parseResult = string.match(args.parsePattern);
+    if (!parseResult)
+      return null;
+    let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+
+// node_modules/date-fns/locale/en-US/_lib/match.js
+var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+var parseOrdinalNumberPattern = /\d+/i;
+var matchEraPatterns = {
+  narrow: /^(b|a)/i,
+  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+  wide: /^(before christ|before common era|anno domini|common era)/i
+};
+var parseEraPatterns = {
+  any: [/^b/i, /^(a|c)/i]
+};
+var matchQuarterPatterns = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+};
+var parseQuarterPatterns = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+var matchMonthPatterns = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+};
+var parseMonthPatterns = {
+  narrow: [
+    /^j/i,
+    /^f/i,
+    /^m/i,
+    /^a/i,
+    /^m/i,
+    /^j/i,
+    /^j/i,
+    /^a/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ],
+  any: [
+    /^ja/i,
+    /^f/i,
+    /^mar/i,
+    /^ap/i,
+    /^may/i,
+    /^jun/i,
+    /^jul/i,
+    /^au/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ]
+};
+var matchDayPatterns = {
+  narrow: /^[smtwf]/i,
+  short: /^(su|mo|tu|we|th|fr|sa)/i,
+  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+};
+var parseDayPatterns = {
+  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+};
+var matchDayPeriodPatterns = {
+  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+};
+var parseDayPeriodPatterns = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mi/i,
+    noon: /^no/i,
+    morning: /morning/i,
+    afternoon: /afternoon/i,
+    evening: /evening/i,
+    night: /night/i
+  }
+};
+var match = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern,
+    parsePattern: parseOrdinalNumberPattern,
+    valueCallback: (value) => parseInt(value, 10)
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns,
+    defaultParseWidth: "any",
+    valueCallback: (index) => index + 1
+  }),
+  month: buildMatchFn({
+    matchPatterns: matchMonthPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseMonthPatterns,
+    defaultParseWidth: "any"
+  }),
+  day: buildMatchFn({
+    matchPatterns: matchDayPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseDayPatterns,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: buildMatchFn({
+    matchPatterns: matchDayPeriodPatterns,
+    defaultMatchWidth: "any",
+    parsePatterns: parseDayPeriodPatterns,
+    defaultParseWidth: "any"
+  })
+};
+
+// node_modules/date-fns/locale/en-US.js
+var enUS = {
+  code: "en-US",
+  formatDistance,
+  formatLong,
+  formatRelative,
+  localize,
+  match,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+// node_modules/date-fns/getDayOfYear.js
+function getDayOfYear(date, options) {
+  const _date = toDate(date, options?.in);
+  const diff = differenceInCalendarDays(_date, startOfYear(_date));
+  const dayOfYear = diff + 1;
+  return dayOfYear;
+}
+
+// node_modules/date-fns/getISOWeek.js
+function getISOWeek(date, options) {
+  const _date = toDate(date, options?.in);
+  const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
+  return Math.round(diff / millisecondsInWeek) + 1;
+}
+
+// node_modules/date-fns/getWeekYear.js
+function getWeekYear(date, options) {
+  const _date = toDate(date, options?.in);
+  const year = _date.getFullYear();
+  const defaultOptions2 = getDefaultOptions();
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const firstWeekOfNextYear = constructFrom(options?.in || date, 0);
+  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
+  firstWeekOfNextYear.setHours(0, 0, 0, 0);
+  const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
+  const firstWeekOfThisYear = constructFrom(options?.in || date, 0);
+  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeekOfThisYear.setHours(0, 0, 0, 0);
+  const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
+  if (+_date >= +startOfNextYear) {
+    return year + 1;
+  } else if (+_date >= +startOfThisYear) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+
+// node_modules/date-fns/startOfWeekYear.js
+function startOfWeekYear(date, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const year = getWeekYear(date, options);
+  const firstWeek = constructFrom(options?.in || date, 0);
+  firstWeek.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeek.setHours(0, 0, 0, 0);
+  const _date = startOfWeek(firstWeek, options);
+  return _date;
+}
+
+// node_modules/date-fns/getWeek.js
+function getWeek(date, options) {
+  const _date = toDate(date, options?.in);
+  const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
+  return Math.round(diff / millisecondsInWeek) + 1;
+}
+
+// node_modules/date-fns/_lib/addLeadingZeros.js
+function addLeadingZeros(number, targetLength) {
+  const sign = number < 0 ? "-" : "";
+  const output = Math.abs(number).toString().padStart(targetLength, "0");
+  return sign + output;
+}
+
+// node_modules/date-fns/_lib/format/lightFormatters.js
+var lightFormatters = {
+  y(date, token) {
+    const signedYear = date.getFullYear();
+    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
+  },
+  M(date, token) {
+    const month = date.getMonth();
+    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
+  },
+  d(date, token) {
+    return addLeadingZeros(date.getDate(), token.length);
+  },
+  a(date, token) {
+    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+  h(date, token) {
+    return addLeadingZeros(date.getHours() % 12 || 12, token.length);
+  },
+  H(date, token) {
+    return addLeadingZeros(date.getHours(), token.length);
+  },
+  m(date, token) {
+    return addLeadingZeros(date.getMinutes(), token.length);
+  },
+  s(date, token) {
+    return addLeadingZeros(date.getSeconds(), token.length);
+  },
+  S(date, token) {
+    const numberOfDigits = token.length;
+    const milliseconds = date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(milliseconds * Math.pow(10, numberOfDigits - 3));
+    return addLeadingZeros(fractionalSeconds, token.length);
+  }
+};
+
+// node_modules/date-fns/_lib/format/formatters.js
+var dayPeriodEnum = {
+  am: "am",
+  pm: "pm",
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night"
+};
+var formatters = {
+  G: function(date, token, localize2) {
+    const era = date.getFullYear() > 0 ? 1 : 0;
+    switch (token) {
+      case "G":
+      case "GG":
+      case "GGG":
+        return localize2.era(era, { width: "abbreviated" });
+      case "GGGGG":
+        return localize2.era(era, { width: "narrow" });
+      case "GGGG":
+      default:
+        return localize2.era(era, { width: "wide" });
+    }
+  },
+  y: function(date, token, localize2) {
+    if (token === "yo") {
+      const signedYear = date.getFullYear();
+      const year = signedYear > 0 ? signedYear : 1 - signedYear;
+      return localize2.ordinalNumber(year, { unit: "year" });
+    }
+    return lightFormatters.y(date, token);
+  },
+  Y: function(date, token, localize2, options) {
+    const signedWeekYear = getWeekYear(date, options);
+    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+    if (token === "YY") {
+      const twoDigitYear = weekYear % 100;
+      return addLeadingZeros(twoDigitYear, 2);
+    }
+    if (token === "Yo") {
+      return localize2.ordinalNumber(weekYear, { unit: "year" });
+    }
+    return addLeadingZeros(weekYear, token.length);
+  },
+  R: function(date, token) {
+    const isoWeekYear = getISOWeekYear(date);
+    return addLeadingZeros(isoWeekYear, token.length);
+  },
+  u: function(date, token) {
+    const year = date.getFullYear();
+    return addLeadingZeros(year, token.length);
+  },
+  Q: function(date, token, localize2) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      case "Q":
+        return String(quarter);
+      case "QQ":
+        return addLeadingZeros(quarter, 2);
+      case "Qo":
+        return localize2.ordinalNumber(quarter, { unit: "quarter" });
+      case "QQQ":
+        return localize2.quarter(quarter, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "QQQQQ":
+        return localize2.quarter(quarter, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "QQQQ":
+      default:
+        return localize2.quarter(quarter, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  q: function(date, token, localize2) {
+    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+    switch (token) {
+      case "q":
+        return String(quarter);
+      case "qq":
+        return addLeadingZeros(quarter, 2);
+      case "qo":
+        return localize2.ordinalNumber(quarter, { unit: "quarter" });
+      case "qqq":
+        return localize2.quarter(quarter, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      case "qqqqq":
+        return localize2.quarter(quarter, {
+          width: "narrow",
+          context: "standalone"
+        });
+      case "qqqq":
+      default:
+        return localize2.quarter(quarter, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  M: function(date, token, localize2) {
+    const month = date.getMonth();
+    switch (token) {
+      case "M":
+      case "MM":
+        return lightFormatters.M(date, token);
+      case "Mo":
+        return localize2.ordinalNumber(month + 1, { unit: "month" });
+      case "MMM":
+        return localize2.month(month, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "MMMMM":
+        return localize2.month(month, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "MMMM":
+      default:
+        return localize2.month(month, { width: "wide", context: "formatting" });
+    }
+  },
+  L: function(date, token, localize2) {
+    const month = date.getMonth();
+    switch (token) {
+      case "L":
+        return String(month + 1);
+      case "LL":
+        return addLeadingZeros(month + 1, 2);
+      case "Lo":
+        return localize2.ordinalNumber(month + 1, { unit: "month" });
+      case "LLL":
+        return localize2.month(month, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      case "LLLLL":
+        return localize2.month(month, {
+          width: "narrow",
+          context: "standalone"
+        });
+      case "LLLL":
+      default:
+        return localize2.month(month, { width: "wide", context: "standalone" });
+    }
+  },
+  w: function(date, token, localize2, options) {
+    const week = getWeek(date, options);
+    if (token === "wo") {
+      return localize2.ordinalNumber(week, { unit: "week" });
+    }
+    return addLeadingZeros(week, token.length);
+  },
+  I: function(date, token, localize2) {
+    const isoWeek = getISOWeek(date);
+    if (token === "Io") {
+      return localize2.ordinalNumber(isoWeek, { unit: "week" });
+    }
+    return addLeadingZeros(isoWeek, token.length);
+  },
+  d: function(date, token, localize2) {
+    if (token === "do") {
+      return localize2.ordinalNumber(date.getDate(), { unit: "date" });
+    }
+    return lightFormatters.d(date, token);
+  },
+  D: function(date, token, localize2) {
+    const dayOfYear = getDayOfYear(date);
+    if (token === "Do") {
+      return localize2.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
+    }
+    return addLeadingZeros(dayOfYear, token.length);
+  },
+  E: function(date, token, localize2) {
+    const dayOfWeek = date.getDay();
+    switch (token) {
+      case "E":
+      case "EE":
+      case "EEE":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "EEEEE":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "EEEEEE":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "formatting"
+        });
+      case "EEEE":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  e: function(date, token, localize2, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      case "e":
+        return String(localDayOfWeek);
+      case "ee":
+        return addLeadingZeros(localDayOfWeek, 2);
+      case "eo":
+        return localize2.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "eee":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "eeeee":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "eeeeee":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "formatting"
+        });
+      case "eeee":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  c: function(date, token, localize2, options) {
+    const dayOfWeek = date.getDay();
+    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      case "c":
+        return String(localDayOfWeek);
+      case "cc":
+        return addLeadingZeros(localDayOfWeek, token.length);
+      case "co":
+        return localize2.ordinalNumber(localDayOfWeek, { unit: "day" });
+      case "ccc":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      case "ccccc":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "standalone"
+        });
+      case "cccccc":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "standalone"
+        });
+      case "cccc":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  i: function(date, token, localize2) {
+    const dayOfWeek = date.getDay();
+    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+    switch (token) {
+      case "i":
+        return String(isoDayOfWeek);
+      case "ii":
+        return addLeadingZeros(isoDayOfWeek, token.length);
+      case "io":
+        return localize2.ordinalNumber(isoDayOfWeek, { unit: "day" });
+      case "iii":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "iiiii":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "iiiiii":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "formatting"
+        });
+      case "iiii":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  a: function(date, token, localize2) {
+    const hours = date.getHours();
+    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    switch (token) {
+      case "a":
+      case "aa":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "aaa":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "aaaaa":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  b: function(date, token, localize2) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours === 12) {
+      dayPeriodEnumValue = dayPeriodEnum.noon;
+    } else if (hours === 0) {
+      dayPeriodEnumValue = dayPeriodEnum.midnight;
+    } else {
+      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    }
+    switch (token) {
+      case "b":
+      case "bb":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "bbb":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "bbbbb":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  B: function(date, token, localize2) {
+    const hours = date.getHours();
+    let dayPeriodEnumValue;
+    if (hours >= 17) {
+      dayPeriodEnumValue = dayPeriodEnum.evening;
+    } else if (hours >= 12) {
+      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+    } else if (hours >= 4) {
+      dayPeriodEnumValue = dayPeriodEnum.morning;
+    } else {
+      dayPeriodEnumValue = dayPeriodEnum.night;
+    }
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  h: function(date, token, localize2) {
+    if (token === "ho") {
+      let hours = date.getHours() % 12;
+      if (hours === 0)
+        hours = 12;
+      return localize2.ordinalNumber(hours, { unit: "hour" });
+    }
+    return lightFormatters.h(date, token);
+  },
+  H: function(date, token, localize2) {
+    if (token === "Ho") {
+      return localize2.ordinalNumber(date.getHours(), { unit: "hour" });
+    }
+    return lightFormatters.H(date, token);
+  },
+  K: function(date, token, localize2) {
+    const hours = date.getHours() % 12;
+    if (token === "Ko") {
+      return localize2.ordinalNumber(hours, { unit: "hour" });
+    }
+    return addLeadingZeros(hours, token.length);
+  },
+  k: function(date, token, localize2) {
+    let hours = date.getHours();
+    if (hours === 0)
+      hours = 24;
+    if (token === "ko") {
+      return localize2.ordinalNumber(hours, { unit: "hour" });
+    }
+    return addLeadingZeros(hours, token.length);
+  },
+  m: function(date, token, localize2) {
+    if (token === "mo") {
+      return localize2.ordinalNumber(date.getMinutes(), { unit: "minute" });
+    }
+    return lightFormatters.m(date, token);
+  },
+  s: function(date, token, localize2) {
+    if (token === "so") {
+      return localize2.ordinalNumber(date.getSeconds(), { unit: "second" });
+    }
+    return lightFormatters.s(date, token);
+  },
+  S: function(date, token) {
+    return lightFormatters.S(date, token);
+  },
+  X: function(date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+    if (timezoneOffset === 0) {
+      return "Z";
+    }
+    switch (token) {
+      case "X":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+      case "XXXX":
+      case "XX":
+        return formatTimezone(timezoneOffset);
+      case "XXXXX":
+      case "XXX":
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+  x: function(date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+    switch (token) {
+      case "x":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+      case "xxxx":
+      case "xx":
+        return formatTimezone(timezoneOffset);
+      case "xxxxx":
+      case "xxx":
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+  O: function(date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+    switch (token) {
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      case "OOOO":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+  z: function(date, token, _localize) {
+    const timezoneOffset = date.getTimezoneOffset();
+    switch (token) {
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      case "zzzz":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+  t: function(date, token, _localize) {
+    const timestamp = Math.trunc(+date / 1000);
+    return addLeadingZeros(timestamp, token.length);
+  },
+  T: function(date, token, _localize) {
+    return addLeadingZeros(+date, token.length);
+  }
+};
+function formatTimezoneShort(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = Math.trunc(absOffset / 60);
+  const minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign + String(hours);
+  }
+  return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
+}
+function formatTimezoneWithOptionalMinutes(offset, delimiter) {
+  if (offset % 60 === 0) {
+    const sign = offset > 0 ? "-" : "+";
+    return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
+  }
+  return formatTimezone(offset, delimiter);
+}
+function formatTimezone(offset, delimiter = "") {
+  const sign = offset > 0 ? "-" : "+";
+  const absOffset = Math.abs(offset);
+  const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
+  const minutes = addLeadingZeros(absOffset % 60, 2);
+  return sign + hours + delimiter + minutes;
+}
+
+// node_modules/date-fns/_lib/format/longFormatters.js
+var dateLongFormatter = (pattern, formatLong2) => {
+  switch (pattern) {
+    case "P":
+      return formatLong2.date({ width: "short" });
+    case "PP":
+      return formatLong2.date({ width: "medium" });
+    case "PPP":
+      return formatLong2.date({ width: "long" });
+    case "PPPP":
+    default:
+      return formatLong2.date({ width: "full" });
+  }
+};
+var timeLongFormatter = (pattern, formatLong2) => {
+  switch (pattern) {
+    case "p":
+      return formatLong2.time({ width: "short" });
+    case "pp":
+      return formatLong2.time({ width: "medium" });
+    case "ppp":
+      return formatLong2.time({ width: "long" });
+    case "pppp":
+    default:
+      return formatLong2.time({ width: "full" });
+  }
+};
+var dateTimeLongFormatter = (pattern, formatLong2) => {
+  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+  const datePattern = matchResult[1];
+  const timePattern = matchResult[2];
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong2);
+  }
+  let dateTimeFormat;
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong2.dateTime({ width: "short" });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong2.dateTime({ width: "medium" });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong2.dateTime({ width: "long" });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong2.dateTime({ width: "full" });
+      break;
+  }
+  return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
+};
+var longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter
+};
+
+// node_modules/date-fns/_lib/protectedTokens.js
+var dayOfYearTokenRE = /^D+$/;
+var weekYearTokenRE = /^Y+$/;
+var throwTokens = ["D", "DD", "YY", "YYYY"];
+function isProtectedDayOfYearToken(token) {
+  return dayOfYearTokenRE.test(token);
+}
+function isProtectedWeekYearToken(token) {
+  return weekYearTokenRE.test(token);
+}
+function warnOrThrowProtectedError(token, format, input) {
+  const _message = message(token, format, input);
+  console.warn(_message);
+  if (throwTokens.includes(token))
+    throw new RangeError(_message);
+}
+function message(token, format, input) {
+  const subject = token[0] === "Y" ? "years" : "days of the month";
+  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+}
+
+// node_modules/date-fns/format.js
+var formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
+var longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+var escapedStringRegExp = /^'([^]*?)'?$/;
+var doubleQuoteRegExp = /''/g;
+var unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+function format(date, formatStr, options) {
+  const defaultOptions2 = getDefaultOptions();
+  const locale = options?.locale ?? defaultOptions2.locale ?? enUS;
+  const firstWeekContainsDate = options?.firstWeekContainsDate ?? options?.locale?.options?.firstWeekContainsDate ?? defaultOptions2.firstWeekContainsDate ?? defaultOptions2.locale?.options?.firstWeekContainsDate ?? 1;
+  const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions2.weekStartsOn ?? defaultOptions2.locale?.options?.weekStartsOn ?? 0;
+  const originalDate = toDate(date, options?.in);
+  if (!isValid(originalDate)) {
+    throw new RangeError("Invalid time value");
+  }
+  let parts = formatStr.match(longFormattingTokensRegExp).map((substring) => {
+    const firstCharacter = substring[0];
+    if (firstCharacter === "p" || firstCharacter === "P") {
+      const longFormatter = longFormatters[firstCharacter];
+      return longFormatter(substring, locale.formatLong);
+    }
+    return substring;
+  }).join("").match(formattingTokensRegExp).map((substring) => {
+    if (substring === "''") {
+      return { isToken: false, value: "'" };
+    }
+    const firstCharacter = substring[0];
+    if (firstCharacter === "'") {
+      return { isToken: false, value: cleanEscapedString(substring) };
+    }
+    if (formatters[firstCharacter]) {
+      return { isToken: true, value: substring };
+    }
+    if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+      throw new RangeError("Format string contains an unescaped latin alphabet character `" + firstCharacter + "`");
+    }
+    return { isToken: false, value: substring };
+  });
+  if (locale.localize.preprocessor) {
+    parts = locale.localize.preprocessor(originalDate, parts);
+  }
+  const formatterOptions = {
+    firstWeekContainsDate,
+    weekStartsOn,
+    locale
+  };
+  return parts.map((part) => {
+    if (!part.isToken)
+      return part.value;
+    const token = part.value;
+    if (!options?.useAdditionalWeekYearTokens && isProtectedWeekYearToken(token) || !options?.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(token)) {
+      warnOrThrowProtectedError(token, formatStr, String(date));
+    }
+    const formatter = formatters[token[0]];
+    return formatter(originalDate, token, locale.localize, formatterOptions);
+  }).join("");
+}
+function cleanEscapedString(input) {
+  const matched = input.match(escapedStringRegExp);
+  if (!matched) {
+    return input;
+  }
+  return matched[1].replace(doubleQuoteRegExp, "'");
+}
+
+// src/utils/date.ts
+var formatDateLog = (isoDateString) => {
+  const date = new Date(isoDateString);
+  const formatted = format(date, "EEE MMM d HH:mm:ss yyyy XXX");
+  return formatted.replace(/([+-]\d{2}):(\d{2})$/, "$1$2");
+};
+
+// src/services/logService.ts
+var log = async (options) => {
+  try {
+    const currentBranch = await getCurrentBranchName();
+    let currentCommitHash = await getCurrentHead();
+    const limit = options?.limit ? parseInt(options.limit, 10) : undefined;
+    let commitCount = 0;
+    console.log(currentCommitHash);
+    while (currentCommitHash && (!limit || commitCount < limit)) {
+      commitCount++;
+      const commitData = JSON.parse(await fs3.readFile(path3.join(OBJECTS_PATH, currentCommitHash.substring(0, 2), currentCommitHash.substring(2)), "utf-8"));
+      console.log(source_default.yellow(`commit ${currentCommitHash} (` + source_default.cyan.bold("HEAD") + source_default.yellow(` -> `) + source_default.green.bold(currentBranch) + source_default.yellow(", ") + source_default.redBright.bold(`origin/${currentBranch}`) + source_default.yellow(", ") + source_default.redBright.bold("origin/HEAD") + source_default.yellow(")")));
+      console.log(`Author: ${commitData.author.name} <${commitData.author.email}>`);
+      console.log(`Date: ${formatDateLog(commitData.timeStamp)}`);
+      console.log(`
+	${commitData.message}
+`);
+      if (!limit || commitCount < limit) {
+        currentCommitHash = commitData.parent;
+      } else {
+        currentCommitHash = null;
+      }
+    }
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.log(source_default.red("Error logging:"), message2);
+    process.exit(1);
+  }
+};
+
+// src/commands/logCommand.ts
+var logCommand = new Command("log").description("Show commit history for the current repository in reverse chronological order").option("-L, --limit <number>", "Limit the number of commits to display").addHelpText("after", `
+Examples:
+  $ brch log                      Show all commits
+  $ brch log -L 5                 Show the last 5 commits
+  $ brch log --limit 10           Show the last 10 commits
+
+Displays each commit with author, date, hash, and message.
+Commits are shown from newest to oldest.
+`).action(log);
+
+// src/services/statusService.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+var getIgnorePatterns = async () => {
+  try {
+    const ignoreContent = await fs4.readFile(IGNORE_PATH, "utf-8");
+    return ignoreContent.split(`
+`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  } catch (error) {
+    return [];
+  }
+};
+var shouldIgnore2 = (name, patterns) => {
+  return patterns.some((pattern) => {
+    if (pattern === name || pattern === `${name}/`) {
+      return true;
+    }
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      return name.endsWith(ext);
+    }
+    if (pattern.endsWith("/") && name === pattern.slice(0, -1)) {
+      return true;
+    }
+    return false;
+  });
+};
+var getTrackedFiles = async (commitHash) => {
+  const trackedFiles = new Map;
+  if (!commitHash)
+    return trackedFiles;
+  try {
+    const commitPath = path4.join(OBJECTS_PATH, commitHash.substring(0, 2), commitHash.substring(2));
+    const commitData = JSON.parse(await fs4.readFile(commitPath, "utf-8"));
+    if (commitData.files && Array.isArray(commitData.files)) {
+      for (const entry of commitData.files) {
+        trackedFiles.set(entry.path, entry.hash);
+      }
+    }
+  } catch (error) {}
+  return trackedFiles;
+};
+var readIndex3 = async () => {
+  try {
+    const content = await fs4.readFile(INDEX_PATH, "utf-8");
+    if (!content)
+      return [];
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed))
+      return parsed.map((e) => ({ path: e.path, hash: e.hash }));
+    if (parsed && typeof parsed === "object")
+      return Object.entries(parsed).map(([p, h]) => ({ path: p, hash: h }));
+    return [];
+  } catch {
+    return [];
+  }
+};
+var normalizeRelativePath3 = (pathValue) => {
+  const normalized = pathValue.split("\\").join("/");
+  if (normalized && !normalized.startsWith("./") && !normalized.startsWith("../") && !normalized.startsWith("/")) {
+    return "./" + normalized;
+  }
+  return normalized;
+};
+var walk = async (dir, repoRoot, ignorePatterns) => {
+  let files = [];
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const res = path4.resolve(dir, entry.name);
+    if (entry.name === VCS_DIR || shouldIgnore2(entry.name, ignorePatterns))
+      continue;
+    if (entry.isDirectory()) {
+      files = files.concat(await walk(res, repoRoot, ignorePatterns));
+    } else {
+      files.push(normalizeRelativePath3(path4.relative(repoRoot, res)));
+    }
+  }
+  return files;
+};
+var status = async () => {
+  try {
+    const currentBranch = await getCurrentBranchName();
+    const currentHead = await getCurrentHead();
+    const trackedFiles = await getTrackedFiles(currentHead);
+    const ignorePatterns = await getIgnorePatterns();
+    const indexEntries = await readIndex3();
+    const indexMap = new Map;
+    for (const entry of indexEntries) {
+      indexMap.set(entry.path, entry.hash);
+    }
+    console.log(`On branch ${source_default.cyan(currentBranch || "detached HEAD")}`);
+    const repoRoot = process.cwd();
+    const allFiles = await walk(repoRoot, repoRoot, ignorePatterns);
+    const stagedAdditions = [];
+    const stagedModifications = [];
+    const stagedDeletions = [];
+    const modifiedFiles = [];
+    const deletedFiles = [];
+    const untrackedFiles = [];
+    const allKnownPaths = new Set([
+      ...allFiles,
+      ...indexMap.keys(),
+      ...trackedFiles.keys()
+    ]);
+    const worktreeSet = new Set(allFiles);
+    for (const relPath of allKnownPaths) {
+      const indexHash = indexMap.get(relPath);
+      const headHash = trackedFiles.get(relPath);
+      const isWorktree = worktreeSet.has(relPath);
+      if (indexHash !== headHash) {
+        if (!headHash && indexHash) {
+          stagedAdditions.push(relPath);
+        } else if (headHash && !indexHash) {
+          stagedDeletions.push(relPath);
+        } else if (headHash && indexHash && headHash !== indexHash) {
+          stagedModifications.push(relPath);
+        }
+      }
+      if (isWorktree) {
+        const fileBuffer = await fs4.readFile(path4.join(repoRoot, relPath));
+        const fileHash = hashContent(fileBuffer);
+        const baseHash = indexHash || headHash;
+        if (baseHash) {
+          if (fileHash !== indexHash && indexHash) {
+            modifiedFiles.push(relPath);
+          } else if (fileHash !== headHash && !indexHash) {
+            modifiedFiles.push(relPath);
+          }
+        } else {
+          untrackedFiles.push(relPath);
+        }
+      } else {
+        if (indexHash || headHash) {
+          if (indexHash) {
+            deletedFiles.push(relPath);
+          }
+        }
+      }
+    }
+    if (stagedAdditions.length > 0 || stagedModifications.length > 0 || stagedDeletions.length > 0) {
+      console.log(`
+${source_default.green("Changes to be committed:")}`);
+      console.log(`  (use "${source_default.cyan("brch reset")}" to unstage)`);
+      for (const file of stagedAdditions)
+        console.log(`	${source_default.green("new file:")}   ${file}`);
+      for (const file of stagedModifications)
+        console.log(`	${source_default.green("modified:")}   ${file}`);
+      for (const file of stagedDeletions)
+        console.log(`	${source_default.green("deleted:")}    ${file}`);
+    }
+    if (modifiedFiles.length > 0 || deletedFiles.length > 0) {
+      console.log(`
+${source_default.red("Changes not staged for commit:")}`);
+      console.log(`  (use "${source_default.cyan("brch add")}" to stage changes)`);
+      for (const file of modifiedFiles)
+        console.log(`	${source_default.red("modified:")}   ${file}`);
+      for (const file of deletedFiles)
+        console.log(`	${source_default.red("deleted:")}    ${file}`);
+    }
+    if (untrackedFiles.length > 0) {
+      console.log(`
+${source_default.red("Untracked files:")}`);
+      console.log(`  (use "${source_default.cyan("brch add")}" to include in what will be committed)`);
+      for (const file of untrackedFiles) {
+        console.log(`	${file}`);
+      }
+    }
+    if (stagedAdditions.length === 0 && stagedModifications.length === 0 && stagedDeletions.length === 0 && modifiedFiles.length === 0 && deletedFiles.length === 0 && untrackedFiles.length === 0) {
+      console.log(source_default.green("nothing to commit, working tree clean"));
+    }
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.log("Error getting status:", message2);
+    process.exit(1);
+  }
+};
+
+// src/commands/statusCommand.ts
+var statusCommand = new Command("status").description("Show the working tree status").addHelpText("after", `
+Examples:
+  $ brch status
+
+Displays:
+  - Changes to be committed (staged files)
+  - Changes not staged for commit (modified tracked files)
+  - Untracked files (new files not yet added)
+
+Use 'brch add <file>...' to stage files for commit.
+`).action(async () => {
+  status();
+});
+
+// src/services/diffService.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+
+// node_modules/diff/libesm/diff/base.js
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== undefined ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = undefined;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = undefined;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(undefined);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path5, added, removed, oldPosInc, options) {
+    const last = path5.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path5.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path5.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0;i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  castInput(value, options) {
+    return value;
+  }
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (;componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+}
+
+// node_modules/diff/libesm/diff/character.js
+class CharacterDiff extends Diff {
+}
+var characterDiff = new CharacterDiff;
+
+// node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+  let i;
+  for (i = 0;i < str1.length && i < str2.length; i++) {
+    if (str1[i] != str2[i]) {
+      return str1.slice(0, i);
+    }
+  }
+  return str1.slice(0, i);
+}
+function longestCommonSuffix(str1, str2) {
+  let i;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+    return "";
+  }
+  for (i = 0;i < str1.length && i < str2.length; i++) {
+    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+      return str1.slice(-i);
+    }
+  }
+  return str1.slice(-i);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  }
+  return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix) {
+    return string + newSuffix;
+  }
+  if (string.slice(-oldSuffix.length) != oldSuffix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  }
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+function overlapCount(a, b) {
+  let startA = 0;
+  if (a.length > b.length) {
+    startA = a.length - b.length;
+  }
+  let endB = b.length;
+  if (a.length < b.length) {
+    endB = a.length;
+  }
+  const map = Array(endB);
+  let k = 0;
+  map[0] = 0;
+  for (let j = 1;j < endB; j++) {
+    if (b[j] == b[k]) {
+      map[j] = map[k];
+    } else {
+      map[j] = k;
+    }
+    while (k > 0 && b[j] != b[k]) {
+      k = map[k];
+    }
+    if (b[j] == b[k]) {
+      k++;
+    }
+  }
+  k = 0;
+  for (let i = startA;i < a.length; i++) {
+    while (k > 0 && a[i] != b[k]) {
+      k = map[k];
+    }
+    if (a[i] == b[k]) {
+      k++;
+    }
+  }
+  return k;
+}
+function trailingWs(string) {
+  let i;
+  for (i = string.length - 1;i >= 0; i--) {
+    if (!string[i].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i + 1);
+}
+function leadingWs(string) {
+  const match2 = string.match(/^\s*/);
+  return match2 ? match2[0] : "";
+}
+
+// node_modules/diff/libesm/diff/word.js
+var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+
+class WordDiff extends Diff {
+  equals(left, right, options) {
+    if (options.ignoreCase) {
+      left = left.toLowerCase();
+      right = right.toLowerCase();
+    }
+    return left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      const segmenter = options.intlSegmenter;
+      if (segmenter.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = Array.from(segmenter.segment(value), (segment) => segment.segment);
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    const tokens = [];
+    let prevPart = null;
+    parts.forEach((part) => {
+      if (/\s/.test(part)) {
+        if (prevPart == null) {
+          tokens.push(part);
+        } else {
+          tokens.push(tokens.pop() + part);
+        }
+      } else if (prevPart != null && /\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part);
+        } else {
+          tokens.push(prevPart + part);
+        }
+      } else {
+        tokens.push(part);
+      }
+      prevPart = part;
+    });
+    return tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i) => {
+      if (i == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, "");
+      }
+    }).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
+    }
+    let lastKeep = null;
+    let insertion = null;
+    let deletion = null;
+    changes.forEach((change) => {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
+      } else {
+        if (insertion || deletion) {
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+        }
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
+      }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+    }
+    return changes;
+  }
+}
+var wordDiff = new WordDiff;
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+  if (deletion && insertion) {
+    const oldWsPrefix = leadingWs(deletion.value);
+    const oldWsSuffix = trailingWs(deletion.value);
+    const newWsPrefix = leadingWs(insertion.value);
+    const newWsSuffix = trailingWs(insertion.value);
+    if (startKeep) {
+      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      const ws = leadingWs(insertion.value);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      const ws = leadingWs(endKeep.value);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
+    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    const endKeepWsPrefix = leadingWs(endKeep.value);
+    const deletionWsSuffix = trailingWs(deletion.value);
+    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    const startKeepWsSuffix = trailingWs(startKeep.value);
+    const deletionWsPrefix = leadingWs(deletion.value);
+    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+
+class WordsWithSpaceDiff extends Diff {
+  tokenize(value) {
+    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex) || [];
+  }
+}
+var wordsWithSpaceDiff = new WordsWithSpaceDiff;
+
+// node_modules/diff/libesm/diff/line.js
+class LineDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes(`
+`)) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes(`
+`)) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith(`
+`)) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith(`
+`)) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+}
+var lineDiff = new LineDiff;
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, `
+`);
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0;i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/diff/sentence.js
+function isSentenceEndPunct(char) {
+  return char == "." || char == "!" || char == "?";
+}
+
+class SentenceDiff extends Diff {
+  tokenize(value) {
+    var _a;
+    const result = [];
+    let tokenStartI = 0;
+    for (let i = 0;i < value.length; i++) {
+      if (i == value.length - 1) {
+        result.push(value.slice(tokenStartI));
+        break;
+      }
+      if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
+        result.push(value.slice(tokenStartI, i + 1));
+        i = tokenStartI = i + 1;
+        while ((_a = value[i + 1]) === null || _a === undefined ? undefined : _a.match(/\s/)) {
+          i++;
+        }
+        result.push(value.slice(tokenStartI, i + 1));
+        tokenStartI = i + 1;
+      }
+    }
+    return result;
+  }
+}
+var sentenceDiff = new SentenceDiff;
+
+// node_modules/diff/libesm/diff/css.js
+class CssDiff extends Diff {
+  tokenize(value) {
+    return value.split(/([{}:;,]|\s+)/);
+  }
+}
+var cssDiff = new CssDiff;
+
+// node_modules/diff/libesm/diff/json.js
+class JsonDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  get useLongestToken() {
+    return true;
+  }
+  castInput(value, options) {
+    const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
+    return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+  }
+  equals(left, right, options) {
+    return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
+  }
+}
+var jsonDiff = new JsonDiff;
+function canonicalize(obj, stack, replacementStack, replacer, key) {
+  stack = stack || [];
+  replacementStack = replacementStack || [];
+  if (replacer) {
+    obj = replacer(key === undefined ? "" : key, obj);
+  }
+  let i;
+  for (i = 0;i < stack.length; i += 1) {
+    if (stack[i] === obj) {
+      return replacementStack[i];
+    }
+  }
+  let canonicalizedObj;
+  if (Object.prototype.toString.call(obj) === "[object Array]") {
+    stack.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i = 0;i < obj.length; i += 1) {
+      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
+    }
+    stack.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (typeof obj === "object" && obj !== null) {
+    stack.push(obj);
+    canonicalizedObj = {};
+    replacementStack.push(canonicalizedObj);
+    const sortedKeys = [];
+    let key2;
+    for (key2 in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key2)) {
+        sortedKeys.push(key2);
+      }
+    }
+    sortedKeys.sort();
+    for (i = 0;i < sortedKeys.length; i += 1) {
+      key2 = sortedKeys[i];
+      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
+    }
+    stack.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+
+// node_modules/diff/libesm/diff/array.js
+class ArrayDiff extends Diff {
+  tokenize(value) {
+    return value.slice();
+  }
+  join(value) {
+    return value;
+  }
+  removeEmpty(value) {
+    return value;
+  }
+}
+var arrayDiff = new ArrayDiff;
+
+// node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0;i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0;i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith(`
+`)) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(formatPatch).join(`
+`);
+  }
+  const ret = [];
+  if (patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "\t" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "\t" + patch.newHeader));
+  for (let i = 0;i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join(`
+`) + `
+`;
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
+  }
+  if (!(options === null || options === undefined ? undefined : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(undefined);
+      } else {
+        callback(formatPatch(patchObj));
+      }
+    } }));
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith(`
+`);
+  const result = text.split(`
+`).map((line) => line + `
+`);
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// src/services/diffService.ts
+var getIgnorePatterns2 = async () => {
+  try {
+    const ignoreContent = await fs5.readFile(IGNORE_PATH, "utf-8");
+    return ignoreContent.split(`
+`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  } catch (error) {
+    return [];
+  }
+};
+var shouldIgnore3 = (name, patterns) => {
+  return patterns.some((pattern) => {
+    if (pattern === name || pattern === `${name}/`) {
+      return true;
+    }
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      return name.endsWith(ext);
+    }
+    if (pattern.endsWith("/") && name === pattern.slice(0, -1)) {
+      return true;
+    }
+    return false;
+  });
+};
+var getTrackedFiles2 = async (commitHash) => {
+  const trackedFiles = new Map;
+  if (!commitHash)
+    return trackedFiles;
+  try {
+    const commitPath = path5.join(OBJECTS_PATH, commitHash.substring(0, 2), commitHash.substring(2));
+    const commitData = JSON.parse(await fs5.readFile(commitPath, "utf-8"));
+    if (commitData.files && Array.isArray(commitData.files)) {
+      for (const entry of commitData.files) {
+        trackedFiles.set(entry.path, entry.hash);
+      }
+    }
+  } catch (error) {}
+  return trackedFiles;
+};
+var getFileContentFromHash = async (hash) => {
+  try {
+    const objectPath = path5.join(OBJECTS_PATH, hash.substring(0, 2), hash.substring(2));
+    return await fs5.readFile(objectPath, "utf-8");
+  } catch (error) {
+    return "";
+  }
+};
+var colorDiffLine = (line) => {
+  if (line.startsWith("+") && !line.startsWith("+++")) {
+    return source_default.green(line);
+  } else if (line.startsWith("-") && !line.startsWith("---")) {
+    return source_default.red(line);
+  } else if (line.startsWith("@@")) {
+    return source_default.cyan(line);
+  } else if (line.startsWith("diff") || line.startsWith("index") || line.startsWith("---") || line.startsWith("+++")) {
+    return source_default.bold(line);
+  }
+  return line;
+};
+var normalizeRelativePath4 = (pathValue) => {
+  const normalized = pathValue.split("\\").join("/");
+  if (normalized && !normalized.startsWith("./") && !normalized.startsWith("../") && !normalized.startsWith("/")) {
+    return "./" + normalized;
+  }
+  return normalized;
+};
+var walk2 = async (dir, repoRoot, ignorePatterns) => {
+  let files = [];
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const res = path5.resolve(dir, entry.name);
+    if (entry.name === VCS_DIR || shouldIgnore3(entry.name, ignorePatterns))
+      continue;
+    if (entry.isDirectory()) {
+      files = files.concat(await walk2(res, repoRoot, ignorePatterns));
+    } else {
+      files.push(normalizeRelativePath4(path5.relative(repoRoot, res)));
+    }
+  }
+  return files;
+};
+var diff = async (filePaths) => {
+  try {
+    const currentHead = await getCurrentHead();
+    const trackedFiles = await getTrackedFiles2(currentHead);
+    const ignorePatterns = await getIgnorePatterns2();
+    if (!currentHead) {
+      console.log(source_default.yellow("No commits yet. Nothing to diff."));
+      return;
+    }
+    const repoRoot = process.cwd();
+    let filesToCompare = [];
+    if (filePaths && filePaths.length > 0) {
+      for (const p of filePaths) {
+        const absolutePath = path5.resolve(repoRoot, p);
+        try {
+          const stats = await fs5.stat(absolutePath);
+          if (stats.isDirectory()) {
+            const dirFiles = await walk2(absolutePath, repoRoot, ignorePatterns);
+            filesToCompare.push(...dirFiles);
+          } else {
+            const relativeToRoot = path5.relative(repoRoot, absolutePath);
+            filesToCompare.push(normalizeRelativePath4(relativeToRoot));
+          }
+        } catch (error) {
+          const relativeToRoot = path5.relative(repoRoot, absolutePath);
+          filesToCompare.push(normalizeRelativePath4(relativeToRoot));
+        }
+      }
+      filesToCompare = [...new Set(filesToCompare)];
+    } else {
+      filesToCompare = await walk2(repoRoot, repoRoot, ignorePatterns);
+    }
+    let hasDiffs = false;
+    for (const relPath of filesToCompare) {
+      try {
+        const fullPath = path5.join(repoRoot, relPath);
+        const fileBuffer = await fs5.readFile(fullPath);
+        const fileHash = hashContent(fileBuffer);
+        const trackedHash = trackedFiles.get(relPath);
+        if (trackedHash && fileHash !== trackedHash) {
+          const oldContent = await getFileContentFromHash(trackedHash);
+          const newContent = fileBuffer.toString("utf-8");
+          const patch = createTwoFilesPatch(`a/${relPath}`, `b/${relPath}`, oldContent, newContent, "HEAD", "Working Directory");
+          const lines = patch.split(`
+`);
+          for (const line of lines) {
+            console.log(colorDiffLine(line));
+          }
+          console.log("");
+          hasDiffs = true;
+        }
+      } catch (error) {}
+    }
+    if (!hasDiffs) {
+      console.log(source_default.green("No changes detected."));
+    }
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.log("Error generating diff:", message2);
+    process.exit(1);
+  }
+};
+
+// src/commands/diffCommand.ts
+var diffCommand = new Command("diff").description("Show changes between working directory and last commit").argument("[files...]", "Specific files to show differences for").addHelpText("after", `
+Examples:
+  $ brch diff                     Show changes for all modified files
+  $ brch diff file.txt            Show changes for a specific file
+  $ brch diff src/                Show changes for all files in a directory
+
+Displays line-by-line differences between your current files and the last committed version.
+Deleted lines are shown in red, and added lines are shown in green.
+`).action(async (files) => {
+  await diff(files);
+});
+
+// src/commands/index.ts
+var registerCommands = (program2) => {
+  program2.addCommand(configCommand);
+  program2.addCommand(initCommand);
+  program2.addCommand(addCommand);
+  program2.addCommand(commitCommand);
+  program2.addCommand(logCommand);
+  program2.addCommand(statusCommand);
+  program2.addCommand(diffCommand);
+};
+
+// src/index.ts
+program.name(VCS_NAME).description("brch - A simple version control system for tracking changes in your project").version("0.0.1").addHelpText("after", `
+Examples:
+  $ brch init                    Initialize a new repository
+  $ brch add .                   Stage all files in current directory
+  $ brch status                  Show current repository status
+  $ brch commit -m "Commit msg"  Commit staged changes
+  $ brch log                     Show commit history
+  $ brch diff                    Show changes in working tree
+  $ brch config set user.name "John Doe"  Set configuration
+
+For more information about a specific command, use:
+  $ brch <command> --help
+`);
 registerCommands(program);
 program.parse(process.argv);