@fractary/codex-cli 0.9.0 → 0.9.1

package/dist/cli.js

@@ -990,6 +990,106 @@ async function initializeUnifiedConfig(configPath, organization, project, option
   };
 }
 
+// src/config/gitignore-utils.ts
+init_esm_shims();
+var DEFAULT_FRACTARY_GITIGNORE = `# .fractary/.gitignore
+# This file is managed by multiple plugins - each plugin manages its own section
+
+# ===== fractary-codex (managed) =====
+codex/cache/
+# ===== end fractary-codex =====
+`;
+var DEFAULT_CACHE_DIR = "codex/cache/";
+async function readFractaryGitignore(projectRoot) {
+  const gitignorePath = path5.join(projectRoot, ".fractary", ".gitignore");
+  try {
+    return await fs.readFile(gitignorePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeFractaryGitignore(projectRoot, content) {
+  const gitignorePath = path5.join(projectRoot, ".fractary", ".gitignore");
+  await fs.mkdir(path5.join(projectRoot, ".fractary"), { recursive: true });
+  await fs.writeFile(gitignorePath, content, "utf-8");
+}
+function normalizeCachePath(cachePath) {
+  let normalized = cachePath.replace(/\\/g, "/");
+  normalized = normalized.replace(/^\.fractary\//, "");
+  if (!normalized.endsWith("/")) {
+    normalized += "/";
+  }
+  return normalized;
+}
+function isCachePathIgnored(gitignoreContent, cachePath) {
+  const normalized = normalizeCachePath(cachePath);
+  const lines = gitignoreContent.split("\n").map((l) => l.trim());
+  return lines.some((line) => {
+    if (line.startsWith("#") || line === "") return false;
+    let normalizedLine = line.replace(/\\/g, "/");
+    if (!normalizedLine.endsWith("/")) {
+      normalizedLine += "/";
+    }
+    return normalizedLine === normalized;
+  });
+}
+function addCachePathToGitignore(gitignoreContent, cachePath, comment) {
+  const normalized = normalizeCachePath(cachePath);
+  if (isCachePathIgnored(gitignoreContent, cachePath)) {
+    return gitignoreContent;
+  }
+  let addition = "";
+  {
+    addition += `
+# ${comment}
+`;
+  }
+  addition += normalized + "\n";
+  return gitignoreContent.trimEnd() + addition;
+}
+async function ensureCachePathIgnored(projectRoot, cachePath) {
+  const gitignorePath = path5.join(projectRoot, ".fractary", ".gitignore");
+  let relativeCachePath = cachePath;
+  if (path5.isAbsolute(cachePath)) {
+    relativeCachePath = path5.relative(path5.join(projectRoot, ".fractary"), cachePath);
+  }
+  relativeCachePath = normalizeCachePath(relativeCachePath);
+  let content = await readFractaryGitignore(projectRoot);
+  const gitignoreExists = content !== null;
+  if (!gitignoreExists) {
+    content = DEFAULT_FRACTARY_GITIGNORE;
+    if (!isCachePathIgnored(content, relativeCachePath)) {
+      content = addCachePathToGitignore(content, relativeCachePath, "Custom cache directory");
+    }
+    await writeFractaryGitignore(projectRoot, content);
+    return {
+      created: true,
+      updated: false,
+      alreadyIgnored: false,
+      gitignorePath
+    };
+  }
+  if (isCachePathIgnored(content, relativeCachePath)) {
+    return {
+      created: false,
+      updated: false,
+      alreadyIgnored: true,
+      gitignorePath
+    };
+  }
+  content = addCachePathToGitignore(content, relativeCachePath, "Custom cache directory");
+  await writeFractaryGitignore(projectRoot, content);
+  return {
+    created: false,
+    updated: true,
+    alreadyIgnored: false,
+    gitignorePath
+  };
+}
+
 // src/commands/config/init.ts
 async function getOrgFromGitRemote() {
   try {
@@ -1060,6 +1160,14 @@ function initCommand() {
         await fs.mkdir(path5.join(process.cwd(), dir), { recursive: true });
         console.log(chalk8.green("\u2713"), chalk8.dim(dir + "/"));
       }
+      const gitignoreResult = await ensureCachePathIgnored(process.cwd(), ".fractary/codex/cache");
+      if (gitignoreResult.created) {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/.gitignore (created)"));
+      } else if (gitignoreResult.updated) {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/.gitignore (updated)"));
+      } else {
+        console.log(chalk8.green("\u2713"), chalk8.dim(".fractary/.gitignore (exists)"));
+      }
       console.log("\nInitializing configuration...");
       const result = await initializeUnifiedConfig(
         configPath,
@@ -1148,8 +1256,9 @@ function migrateCommand() {
       let legacyConfig;
       try {
         legacyConfig = JSON.parse(legacyContent);
-      } catch {
+      } catch (parseError) {
         console.error(chalk8.red("Error:"), "Invalid JSON in legacy config file.");
+        console.error(chalk8.dim("Details:"), parseError.message);
         process.exit(1);
       }
       if (!options.json && !options.dryRun) {
@@ -1210,19 +1319,34 @@ function migrateCommand() {
       }
       if (!options.dryRun) {
         await writeYamlConfig(migrationResult.yamlConfig, newConfigPath);
-        const cacheDir = path5.join(process.cwd(), ".codex-cache");
+        const configuredCacheDir = migrationResult.yamlConfig.cacheDir || ".fractary/codex/cache";
+        const cacheDir = path5.join(process.cwd(), configuredCacheDir);
         await fs.mkdir(cacheDir, { recursive: true });
+        const gitignoreResult = await ensureCachePathIgnored(process.cwd(), configuredCacheDir);
+        const isCustomCachePath = normalizeCachePath(configuredCacheDir) !== DEFAULT_CACHE_DIR;
         if (!options.json) {
           console.log(chalk8.green("\u2713"), "YAML configuration created");
           console.log(chalk8.green("\u2713"), "Cache directory initialized");
           if (migrationResult.backupPath) {
             console.log(chalk8.green("\u2713"), "Legacy config backed up");
           }
+          if (gitignoreResult.created) {
+            console.log(chalk8.green("\u2713"), ".fractary/.gitignore created");
+          } else if (gitignoreResult.updated) {
+            console.log(chalk8.green("\u2713"), ".fractary/.gitignore updated with cache path");
+          } else if (gitignoreResult.alreadyIgnored) {
+            console.log(chalk8.green("\u2713"), "Cache path already in .fractary/.gitignore");
+          }
+          if (isCustomCachePath) {
+            console.log("");
+            console.log(chalk8.yellow("\u26A0 Custom cache directory detected:"), chalk8.dim(configuredCacheDir));
+            console.log(chalk8.dim("  Ensure .fractary/.gitignore includes this path to avoid committing cache files."));
+          }
           console.log("");
           console.log(chalk8.bold("New Configuration:"));
           console.log(chalk8.dim(`  Path: ${newConfigPath}`));
           console.log(chalk8.dim(`  Organization: ${migrationResult.yamlConfig.organization}`));
-          console.log(chalk8.dim(`  Cache: ${migrationResult.yamlConfig.cacheDir || ".codex-cache"}`));
+          console.log(chalk8.dim(`  Cache: ${configuredCacheDir}`));
           console.log(chalk8.dim(`  Storage Providers: ${migrationResult.yamlConfig.storage?.length || 0}`));
           console.log("");
           console.log(chalk8.bold("Next Steps:"));
@@ -1793,7 +1917,7 @@ function syncCommand() {
       const targetFiles = await Promise.all(
         Array.from(matchedFilePaths).map(async (filePath) => {
           const fullPath = path5.join(sourceDir, filePath);
-          const stats = await import('fs/promises').then((fs8) => fs8.stat(fullPath));
+          const stats = await import('fs/promises').then((fs9) => fs9.stat(fullPath));
           return {
             path: filePath,
             size: stats.size,