@fractary/codex-cli 0.8.0 → 0.9.1

package/dist/cli.cjs

@@ -2,7 +2,7 @@
 'use strict';
 
 var fs$1 = require('fs/promises');
-var path3 = require('path');
+var path4 = require('path');
 var yaml = require('js-yaml');
 var codex = require('@fractary/codex');
 var os = require('os');
@@ -34,7 +34,7 @@ function _interopNamespace(e) {
 }
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs$1);
-var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
 var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
@@ -194,7 +194,7 @@ async function migrateConfig(legacyConfigPath, options) {
   }
 }
 async function writeYamlConfig(config, outputPath) {
-  const dir = path3__namespace.dirname(outputPath);
+  const dir = path4__namespace.dirname(outputPath);
   await fs__namespace.mkdir(dir, { recursive: true });
   const yamlContent = yaml__namespace.dump(config, {
     indent: 2,
@@ -418,7 +418,7 @@ var init_codex_client = __esm({
         const { readYamlConfig: readYamlConfig2 } = await Promise.resolve().then(() => (init_migrate_config(), migrate_config_exports));
         const { resolveEnvVarsInConfig: resolveEnvVarsInConfig2 } = await Promise.resolve().then(() => (init_config_types(), config_types_exports));
         try {
-          const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+          const configPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
           let config;
           try {
             config = await readYamlConfig2(configPath);
@@ -688,7 +688,7 @@ function getTempCodexPath(config) {
   const codexRepo = config.codex_repository || "codex";
   const sanitizedOrg = sanitizePathComponent(config.organization);
   const sanitizedRepo = sanitizePathComponent(codexRepo);
-  return path3__namespace.join(
+  return path4__namespace.join(
     os__namespace.tmpdir(),
     "fractary-codex-clone",
     `${sanitizedOrg}-${sanitizedRepo}-${process.pid}`
@@ -696,7 +696,7 @@ function getTempCodexPath(config) {
 }
 async function isValidGitRepo(repoPath) {
   try {
-    const gitDir = path3__namespace.join(repoPath, ".git");
+    const gitDir = path4__namespace.join(repoPath, ".git");
     const stats = await fs__namespace.stat(gitDir);
     return stats.isDirectory();
   } catch {
@@ -729,7 +729,7 @@ async function execGit(repoPath, args) {
   }
 }
 async function gitClone(url, targetPath, options) {
-  const parentDir = path3__namespace.dirname(targetPath);
+  const parentDir = path4__namespace.dirname(targetPath);
   await fs__namespace.mkdir(parentDir, { recursive: true });
   const args = ["clone"];
   if (options?.depth) {
@@ -901,7 +901,229 @@ init_cjs_shims();
 
 // src/commands/config/init.ts
 init_cjs_shims();
-init_migrate_config();
+
+// src/config/unified-config.ts
+init_cjs_shims();
+function sanitizeForS3BucketName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").substring(0, 63);
+}
+function getDefaultUnifiedConfig(organization, project) {
+  const sanitizedProject = sanitizeForS3BucketName(project);
+  return {
+    file: {
+      schema_version: "2.0",
+      sources: {
+        specs: {
+          type: "s3",
+          bucket: `${sanitizedProject}-files`,
+          prefix: "specs/",
+          region: "us-east-1",
+          local: {
+            base_path: ".fractary/specs"
+          },
+          push: {
+            compress: false,
+            keep_local: true
+          },
+          auth: {
+            profile: "default"
+          }
+        },
+        logs: {
+          type: "s3",
+          bucket: `${sanitizedProject}-files`,
+          prefix: "logs/",
+          region: "us-east-1",
+          local: {
+            base_path: ".fractary/logs"
+          },
+          push: {
+            compress: true,
+            keep_local: true
+          },
+          auth: {
+            profile: "default"
+          }
+        }
+      }
+    },
+    codex: {
+      schema_version: "2.0",
+      organization,
+      project,
+      dependencies: {}
+    }
+  };
+}
+async function readUnifiedConfig(configPath) {
+  try {
+    const content = await fs__namespace.readFile(configPath, "utf-8");
+    const config = yaml__namespace.load(content);
+    return config;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeUnifiedConfig(config, outputPath) {
+  const dir = path4__namespace.dirname(outputPath);
+  await fs__namespace.mkdir(dir, { recursive: true });
+  const yamlContent = yaml__namespace.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  await fs__namespace.writeFile(outputPath, yamlContent, "utf-8");
+}
+function mergeUnifiedConfigs(existing, updates) {
+  const merged = {};
+  if (updates.file || existing.file) {
+    merged.file = {
+      schema_version: updates.file?.schema_version || existing.file?.schema_version || "2.0",
+      sources: {
+        ...existing.file?.sources || {},
+        ...updates.file?.sources || {}
+      }
+    };
+  }
+  if (updates.codex || existing.codex) {
+    merged.codex = {
+      schema_version: updates.codex?.schema_version || existing.codex?.schema_version || "2.0",
+      organization: updates.codex?.organization || existing.codex?.organization || "default",
+      project: updates.codex?.project || existing.codex?.project || "default",
+      dependencies: {
+        ...existing.codex?.dependencies || {},
+        ...updates.codex?.dependencies || {}
+      }
+    };
+  }
+  return merged;
+}
+async function initializeUnifiedConfig(configPath, organization, project, options) {
+  const existingConfig = await readUnifiedConfig(configPath);
+  if (existingConfig && !options?.force) {
+    const defaultConfig = getDefaultUnifiedConfig(organization, project);
+    const merged = mergeUnifiedConfigs(existingConfig, defaultConfig);
+    await writeUnifiedConfig(merged, configPath);
+    return {
+      created: false,
+      merged: true,
+      config: merged
+    };
+  }
+  const config = getDefaultUnifiedConfig(organization, project);
+  await writeUnifiedConfig(config, configPath);
+  return {
+    created: true,
+    merged: false,
+    config
+  };
+}
+
+// src/config/gitignore-utils.ts
+init_cjs_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 = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
+  try {
+    return await fs__namespace.readFile(gitignorePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeFractaryGitignore(projectRoot, content) {
+  const gitignorePath = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
+  await fs__namespace.mkdir(path4__namespace.join(projectRoot, ".fractary"), { recursive: true });
+  await fs__namespace.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 = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
+  let relativeCachePath = cachePath;
+  if (path4__namespace.isAbsolute(cachePath)) {
+    relativeCachePath = path4__namespace.relative(path4__namespace.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 {
     const { execSync } = __require("child_process");
@@ -923,9 +1145,9 @@ async function fileExists(filePath) {
 }
 function initCommand() {
   const cmd = new commander.Command("init");
-  cmd.description("Initialize Codex v3.0 with YAML configuration").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--mcp", "Enable MCP server registration").option("--force", "Overwrite existing configuration").action(async (options) => {
+  cmd.description("Initialize unified Fractary configuration (.fractary/config.yaml)").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--project <name>", "Project name (default: derived from directory)").option("--force", "Overwrite existing configuration").action(async (options) => {
     try {
-      console.log(chalk8__default.default.blue("Initializing Codex v3.0 (YAML format)...\n"));
+      console.log(chalk8__default.default.blue("Initializing unified Fractary configuration...\n"));
       let org = options.org;
       if (!org) {
         org = await getOrgFromGitRemote();
@@ -934,60 +1156,79 @@ function initCommand() {
         try {
           const { resolveOrganization } = await import('@fractary/codex');
           org = resolveOrganization({
-            repoName: path3__namespace.basename(process.cwd())
+            repoName: path4__namespace.basename(process.cwd())
           });
         } catch {
         }
       }
       if (!org) {
-        org = path3__namespace.basename(process.cwd()).split("-")[0] || "default";
+        org = path4__namespace.basename(process.cwd()).split("-")[0] || "default";
         console.log(chalk8__default.default.yellow(`\u26A0 Could not detect organization, using: ${org}`));
         console.log(chalk8__default.default.dim("  Use --org <slug> to specify explicitly\n"));
       } else {
         console.log(chalk8__default.default.dim(`Organization: ${chalk8__default.default.cyan(org)}
 `));
       }
-      const configDir = path3__namespace.join(process.cwd(), ".fractary", "codex");
-      const configPath = path3__namespace.join(configDir, "config.yaml");
+      let project = options.project;
+      if (!project) {
+        project = path4__namespace.basename(process.cwd());
+        console.log(chalk8__default.default.dim(`Project: ${chalk8__default.default.cyan(project)}
+`));
+      }
+      const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
       const configExists = await fileExists(configPath);
       if (configExists && !options.force) {
-        console.log(chalk8__default.default.yellow("\u26A0 Configuration already exists at .fractary/codex/config.yaml"));
-        console.log(chalk8__default.default.dim("Use --force to overwrite"));
-        process.exit(1);
+        console.log(chalk8__default.default.yellow(`\u26A0 Configuration already exists at .fractary/config.yaml`));
+        console.log(chalk8__default.default.dim("Merging with existing configuration...\n"));
       }
       console.log("Creating directory structure...");
       const dirs = [
+        ".fractary",
+        ".fractary/specs",
+        ".fractary/logs",
         ".fractary/codex",
         ".fractary/codex/cache"
       ];
       for (const dir of dirs) {
-        await fs__namespace.mkdir(path3__namespace.join(process.cwd(), dir), { recursive: true });
+        await fs__namespace.mkdir(path4__namespace.join(process.cwd(), dir), { recursive: true });
         console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(dir + "/"));
       }
-      console.log("\nCreating YAML configuration...");
-      const config = getDefaultYamlConfig(org);
-      if (options.mcp && config.mcp) {
-        config.mcp.enabled = true;
+      const gitignoreResult = await ensureCachePathIgnored(process.cwd(), ".fractary/codex/cache");
+      if (gitignoreResult.created) {
+        console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/.gitignore (created)"));
+      } else if (gitignoreResult.updated) {
+        console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/.gitignore (updated)"));
+      } else {
+        console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/.gitignore (exists)"));
+      }
+      console.log("\nInitializing configuration...");
+      const result = await initializeUnifiedConfig(
+        configPath,
+        org,
+        project,
+        { force: options.force }
+      );
+      if (result.created) {
+        console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/config.yaml (created)"));
+      } else if (result.merged) {
+        console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/config.yaml (merged with existing)"));
       }
-      await writeYamlConfig(config, configPath);
-      console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/codex/config.yaml"));
-      console.log(chalk8__default.default.green("\n\u2713 Codex v4.0 initialized successfully!\n"));
+      console.log(chalk8__default.default.green("\n\u2713 Unified configuration initialized successfully!\n"));
       console.log(chalk8__default.default.bold("Configuration:"));
       console.log(chalk8__default.default.dim(`  Organization: ${org}`));
-      console.log(chalk8__default.default.dim(`  Cache: .fractary/codex/cache/`));
-      console.log(chalk8__default.default.dim(`  Config: .fractary/codex/config.yaml`));
-      if (options.mcp) {
-        console.log(chalk8__default.default.dim(`  MCP Server: Enabled (port 3000)`));
-      }
-      console.log(chalk8__default.default.bold("\nStorage providers configured:"));
-      console.log(chalk8__default.default.dim("  - Local filesystem (./knowledge)"));
-      console.log(chalk8__default.default.dim("  - GitHub (requires GITHUB_TOKEN)"));
-      console.log(chalk8__default.default.dim("  - HTTP endpoint"));
+      console.log(chalk8__default.default.dim(`  Project: ${project}`));
+      console.log(chalk8__default.default.dim(`  Config: .fractary/config.yaml`));
+      console.log(chalk8__default.default.bold("\nFile plugin sources:"));
+      console.log(chalk8__default.default.dim("  - specs: .fractary/specs/ \u2192 S3"));
+      console.log(chalk8__default.default.dim("  - logs: .fractary/logs/ \u2192 S3"));
+      console.log(chalk8__default.default.bold("\nCodex plugin:"));
+      console.log(chalk8__default.default.dim("  - Cache: .fractary/codex/cache/"));
+      console.log(chalk8__default.default.dim("  - Dependencies: (none configured)"));
       console.log(chalk8__default.default.bold("\nNext steps:"));
-      console.log(chalk8__default.default.dim('  1. Set your GitHub token: export GITHUB_TOKEN="your_token"'));
-      console.log(chalk8__default.default.dim("  2. Edit .fractary/codex/config.yaml to configure storage providers"));
-      console.log(chalk8__default.default.dim("  3. Fetch a document: fractary codex fetch codex://org/project/path"));
-      console.log(chalk8__default.default.dim("  4. Check cache: fractary codex cache list"));
+      console.log(chalk8__default.default.dim("  1. Configure AWS credentials for S3 access"));
+      console.log(chalk8__default.default.dim("  2. Edit .fractary/config.yaml to add external project dependencies"));
+      console.log(chalk8__default.default.dim("  3. Access current project files: codex://specs/SPEC-001.md"));
+      console.log(chalk8__default.default.dim("  4. Access external projects: codex://org/project/docs/README.md"));
     } catch (error) {
       console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
@@ -1014,8 +1255,8 @@ function migrateCommand() {
   const cmd = new commander.Command("migrate");
   cmd.description("Migrate legacy JSON configuration to v3.0 YAML format").option("--dry-run", "Show migration plan without executing").option("--no-backup", "Skip creating backup of old config").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const legacyConfigPath = path3__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
-      const newConfigPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const legacyConfigPath = path4__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
+      const newConfigPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
       if (!await fileExists2(legacyConfigPath)) {
         if (options.json) {
           console.log(JSON.stringify({
@@ -1048,8 +1289,9 @@ function migrateCommand() {
       let legacyConfig;
       try {
         legacyConfig = JSON.parse(legacyContent);
-      } catch {
+      } catch (parseError) {
         console.error(chalk8__default.default.red("Error:"), "Invalid JSON in legacy config file.");
+        console.error(chalk8__default.default.dim("Details:"), parseError.message);
         process.exit(1);
       }
       if (!options.json && !options.dryRun) {
@@ -1110,19 +1352,34 @@ function migrateCommand() {
       }
       if (!options.dryRun) {
         await writeYamlConfig(migrationResult.yamlConfig, newConfigPath);
-        const cacheDir = path3__namespace.join(process.cwd(), ".codex-cache");
+        const configuredCacheDir = migrationResult.yamlConfig.cacheDir || ".fractary/codex/cache";
+        const cacheDir = path4__namespace.join(process.cwd(), configuredCacheDir);
         await fs__namespace.mkdir(cacheDir, { recursive: true });
+        const gitignoreResult = await ensureCachePathIgnored(process.cwd(), configuredCacheDir);
+        const isCustomCachePath = normalizeCachePath(configuredCacheDir) !== DEFAULT_CACHE_DIR;
         if (!options.json) {
           console.log(chalk8__default.default.green("\u2713"), "YAML configuration created");
           console.log(chalk8__default.default.green("\u2713"), "Cache directory initialized");
           if (migrationResult.backupPath) {
             console.log(chalk8__default.default.green("\u2713"), "Legacy config backed up");
           }
+          if (gitignoreResult.created) {
+            console.log(chalk8__default.default.green("\u2713"), ".fractary/.gitignore created");
+          } else if (gitignoreResult.updated) {
+            console.log(chalk8__default.default.green("\u2713"), ".fractary/.gitignore updated with cache path");
+          } else if (gitignoreResult.alreadyIgnored) {
+            console.log(chalk8__default.default.green("\u2713"), "Cache path already in .fractary/.gitignore");
+          }
+          if (isCustomCachePath) {
+            console.log("");
+            console.log(chalk8__default.default.yellow("\u26A0 Custom cache directory detected:"), chalk8__default.default.dim(configuredCacheDir));
+            console.log(chalk8__default.default.dim("  Ensure .fractary/.gitignore includes this path to avoid committing cache files."));
+          }
           console.log("");
           console.log(chalk8__default.default.bold("New Configuration:"));
           console.log(chalk8__default.default.dim(`  Path: ${newConfigPath}`));
           console.log(chalk8__default.default.dim(`  Organization: ${migrationResult.yamlConfig.organization}`));
-          console.log(chalk8__default.default.dim(`  Cache: ${migrationResult.yamlConfig.cacheDir || ".codex-cache"}`));
+          console.log(chalk8__default.default.dim(`  Cache: ${configuredCacheDir}`));
           console.log(chalk8__default.default.dim(`  Storage Providers: ${migrationResult.yamlConfig.storage?.length || 0}`));
           console.log("");
           console.log(chalk8__default.default.bold("Next Steps:"));
@@ -1131,7 +1388,7 @@ function migrateCommand() {
           console.log(chalk8__default.default.dim("  3. Test fetching: fractary codex fetch codex://org/project/path"));
           if (migrationResult.backupPath) {
             console.log("");
-            console.log(chalk8__default.default.dim(`Backup saved: ${path3__namespace.basename(migrationResult.backupPath)}`));
+            console.log(chalk8__default.default.dim(`Backup saved: ${path4__namespace.basename(migrationResult.backupPath)}`));
           }
         }
       }
@@ -1341,8 +1598,8 @@ async function fileExists3(filePath) {
   }
 }
 async function checkConfiguration() {
-  const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
-  const legacyConfigPath = path3__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
+  const configPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+  const legacyConfigPath = path4__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
   try {
     if (!await fileExists3(configPath)) {
       if (await fileExists3(legacyConfigPath)) {
@@ -1449,7 +1706,7 @@ async function checkCache() {
   }
 }
 async function checkStorage() {
-  const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+  const configPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
   try {
     const config = await readYamlConfig(configPath);
     const providers = config.storage || [];
@@ -1607,7 +1864,7 @@ function syncCommand() {
   const cmd = new commander.Command("sync");
   cmd.description("Sync single project with codex repository").argument("[name]", "Project name (auto-detected if not provided)").option("--env <env>", "Target environment (dev/test/staging/prod)", "prod").option("--dry-run", "Show what would sync without executing").option("--direction <dir>", "Sync direction (to-codex/from-codex/bidirectional)", "bidirectional").option("--include <pattern>", "Include files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--exclude <pattern>", "Exclude files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--force", "Force sync without checking timestamps").option("--json", "Output as JSON").action(async (name, options) => {
     try {
-      const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const configPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
       let config;
       try {
         config = await readYamlConfig(configPath);
@@ -1641,7 +1898,7 @@ function syncCommand() {
       const syncManager = createSyncManager({
         localStorage,
         config: config.sync,
-        manifestPath: path3__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
+        manifestPath: path4__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
       });
       const defaultToCodexPatterns = [
         "docs/**/*.md",
@@ -1692,8 +1949,8 @@ function syncCommand() {
       }
       const targetFiles = await Promise.all(
         Array.from(matchedFilePaths).map(async (filePath) => {
-          const fullPath = path3__namespace.join(sourceDir, filePath);
-          const stats = await import('fs/promises').then((fs7) => fs7.stat(fullPath));
+          const fullPath = path4__namespace.join(sourceDir, filePath);
+          const stats = await import('fs/promises').then((fs9) => fs9.stat(fullPath));
           return {
             path: filePath,
             size: stats.size,
@@ -2141,7 +2398,7 @@ function typesAddCommand() {
         console.log(chalk8__default.default.dim("Examples: 30m, 24h, 7d"));
         process.exit(1);
       }
-      const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const configPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
       const config = await readYamlConfig(configPath);
       if (!config.types) {
         config.types = { custom: {} };
@@ -2210,7 +2467,7 @@ function typesRemoveCommand() {
         process.exit(1);
       }
       const typeInfo = registry.get(name);
-      const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
+      const configPath = path4__namespace.join(process.cwd(), ".fractary", "codex", "config.yaml");
       const config = await readYamlConfig(configPath);
       if (!config.types?.custom?.[name]) {
         console.error(chalk8__default.default.red("Error:"), `Custom type "${name}" not found in configuration.`);
@@ -2266,8 +2523,8 @@ function typesCommand() {
   return cmd;
 }
 var __filename2 = url.fileURLToPath(importMetaUrl);
-var __dirname$1 = path3.dirname(__filename2);
-var packageJson = JSON.parse(fs.readFileSync(path3.join(__dirname$1, "../package.json"), "utf-8"));
+var __dirname$1 = path4.dirname(__filename2);
+var packageJson = JSON.parse(fs.readFileSync(path4.join(__dirname$1, "../package.json"), "utf-8"));
 var VERSION = packageJson.version;
 function createCLI() {
   const program = new commander.Command("fractary-codex");