@fractary/codex-mcp 0.10.0 → 0.10.3

package/dist/cli.cjs

@@ -12272,11 +12272,14 @@ function matchToCodexPattern(filePath, patterns) {
   }
   return patterns.some((pattern) => matchPattern(pattern, filePath));
 }
-function matchFromCodexPattern(codexFilePath, patterns, targetProject) {
+function matchFromCodexPattern(codexFilePath, patterns, targetProject, options) {
   if (!patterns || patterns.length === 0) {
     return false;
   }
   return patterns.some((pattern) => {
+    if (pattern.startsWith(CODEX_URI_PREFIX2)) {
+      return matchCodexUri(pattern, codexFilePath, targetProject, options);
+    }
     if (pattern.startsWith("projects/")) {
       return matchPattern(pattern, codexFilePath);
     }
@@ -12294,6 +12297,21 @@ function matchFromCodexPattern(codexFilePath, patterns, targetProject) {
     }
   });
 }
+function matchCodexUri(uriPattern, codexFilePath, targetProject, options) {
+  let withoutPrefix = uriPattern.slice(CODEX_URI_PREFIX2.length);
+  withoutPrefix = withoutPrefix.replace(/{org}/g, options?.org || "").replace(/{project}/g, targetProject).replace(/{codex_repo}/g, options?.codexRepo || "");
+  const parts = withoutPrefix.split("/");
+  if (parts.length < 2) {
+    return false;
+  }
+  const project = parts[1];
+  const pathPattern = parts.slice(2).join("/");
+  if (!project) {
+    return false;
+  }
+  const fullPattern = pathPattern ? `projects/${project}/${pathPattern}` : `projects/${project}/**`;
+  return matchPattern(fullPattern, codexFilePath);
+}
 function extractProjectFromCodexPath(codexFilePath) {
   const firstSlashIndex = codexFilePath.indexOf("/");
   if (firstSlashIndex === -1) {
@@ -12308,15 +12326,26 @@ function getRelativePath(codexFilePath) {
   }
   return codexFilePath.substring(firstSlashIndex + 1);
 }
-function expandPlaceholders(patterns, targetProject) {
+function expandPlaceholders(patterns, targetProject, options) {
   if (!patterns) {
     return patterns;
   }
-  return patterns.map((pattern) => pattern.replace(/{project}/g, targetProject));
+  return patterns.map((pattern) => {
+    let expanded = pattern.replace(/{project}/g, targetProject);
+    if (options?.org) {
+      expanded = expanded.replace(/{org}/g, options.org);
+    }
+    if (options?.codexRepo) {
+      expanded = expanded.replace(/{codex_repo}/g, options.codexRepo);
+    }
+    return expanded;
+  });
 }
+var CODEX_URI_PREFIX2;
 var init_directional_patterns = __esm2({
   "src/sync/directional-patterns.ts"() {
     init_matcher();
+    CODEX_URI_PREFIX2 = "codex://";
   }
 });
 var FORBIDDEN_PATTERNS = [
@@ -12667,12 +12696,21 @@ var SyncRulesSchema = external_exports.object({
   defaultInclude: external_exports.array(external_exports.string()).optional(),
   defaultExclude: external_exports.array(external_exports.string()).optional()
 });
+var DirectionalSyncConfigSchema = external_exports.object({
+  /** Patterns to include (required) */
+  include: external_exports.array(external_exports.string()),
+  /** Patterns to exclude (optional) */
+  exclude: external_exports.array(external_exports.string()).optional()
+});
 var DirectionalSyncSchema = external_exports.object({
+  // New format (v0.7.0+) - Recommended
   // Patterns for files to push from this project to codex
-  to_codex: external_exports.array(external_exports.string()).optional(),
+  to_codex: DirectionalSyncConfigSchema.optional(),
   // Patterns for files to pull from codex to this project
-  // Format: "project-name/path/pattern" or "project-name/**"
-  from_codex: external_exports.array(external_exports.string()).optional(),
+  from_codex: DirectionalSyncConfigSchema.optional(),
+  // Global exclude patterns (applied to both directions)
+  exclude: external_exports.array(external_exports.string()).optional(),
+  // Legacy format (deprecated, backward compatible)
   // Org-level defaults (only in codex repository config)
   default_to_codex: external_exports.array(external_exports.string()).optional(),
   default_from_codex: external_exports.array(external_exports.string()).optional()
@@ -14571,9 +14609,57 @@ var CacheManager = class {
 function createCacheManager(config) {
   return new CacheManager(config);
 }
-
-// src/cli.ts
-var import_fs = require("fs");
+function expandEnvVars(value, options = {}) {
+  const env = options.env ?? process.env;
+  return value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+    const envValue = env[varName];
+    if (envValue === void 0) {
+      if (options.warnOnMissing) {
+        console.warn(`Warning: Environment variable ${varName} is not set`);
+      }
+      if (options.onMissing) {
+        options.onMissing(varName);
+      }
+      return match;
+    }
+    return envValue;
+  });
+}
+function expandEnvVarsInConfig(config, options = {}) {
+  if (typeof config === "string") {
+    return expandEnvVars(config, options);
+  }
+  if (Array.isArray(config)) {
+    return config.map((item) => expandEnvVarsInConfig(item, options));
+  }
+  if (config !== null && typeof config === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(config)) {
+      result[key] = expandEnvVarsInConfig(value, options);
+    }
+    return result;
+  }
+  return config;
+}
+async function readUnifiedConfig(configPath, options = {}) {
+  const content = await fs3.readFile(configPath, "utf-8");
+  let config = load(content);
+  if (options.expandEnv !== false) {
+    const envOptions = {
+      env: options.env,
+      warnOnMissing: options.warnOnMissingEnv
+    };
+    config = expandEnvVarsInConfig(config, envOptions);
+  }
+  return config;
+}
+var SIZE_MULTIPLIERS = {
+  B: 1,
+  KB: 1024,
+  MB: 1024 * 1024,
+  GB: 1024 * 1024 * 1024,
+  TB: 1024 * 1024 * 1024 * 1024
+};
 
 // src/server.ts
 init_cjs_shims();
@@ -15051,58 +15137,44 @@ var McpServer = class {
 };
 
 // src/cli.ts
-function expandEnvVars(obj) {
-  if (typeof obj === "string") {
-    return obj.replace(/\$\{([^}]+)\}/g, (_, varName) => {
-      return process.env[varName] || `\${${varName}}`;
-    });
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => expandEnvVars(item));
-  }
-  if (obj !== null && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = expandEnvVars(value);
-    }
-    return result;
-  }
-  return obj;
-}
 var program2 = new Command();
 program2.name("fractary-codex-mcp").description("MCP server for Fractary Codex knowledge management").version("0.8.0").option("--config <path>", "Path to config file", ".fractary/config.yaml").action(async (options) => {
-  let config = {};
+  let codexConfig = void 0;
+  let fileConfig = void 0;
   try {
-    const configFile = (0, import_fs.readFileSync)(options.config, "utf-8");
-    const rawConfig = load(configFile);
-    if (rawConfig && typeof rawConfig === "object" && "codex" in rawConfig) {
-      config = {
-        ...rawConfig.codex,
-        // Preserve file section if present (for file plugin integration)
-        file: rawConfig.file
-      };
-    } else {
-      config = rawConfig || {};
-    }
-    config = expandEnvVars(config);
+    const unifiedConfig = await readUnifiedConfig(options.config, {
+      expandEnv: true
+    });
+    codexConfig = unifiedConfig.codex;
+    fileConfig = unifiedConfig.file;
   } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
     if (options.config !== ".fractary/config.yaml") {
       console.error(`Warning: Could not load config file: ${options.config}`);
+      console.error(`  Error: ${errorMessage}`);
+    } else {
+      if (!errorMessage.includes("ENOENT")) {
+        console.error(`Warning: Config file exists but could not be parsed: ${errorMessage}`);
+      }
     }
   }
-  const storageConfig = {
-    ...config.storage || {}
-  };
-  if (config.archive) {
+  const storageConfig = {};
+  if (codexConfig?.storage) {
+    Object.assign(storageConfig, { providers: codexConfig.storage });
+  }
+  if (codexConfig?.archive) {
     storageConfig.s3Archive = {
-      projects: config.archive.projects || {},
+      projects: codexConfig.archive.projects || {},
       fractaryCli: process.env.FRACTARY_CLI || "fractary"
     };
   }
+  if (fileConfig) {
+    storageConfig.file = fileConfig;
+  }
   const storage = createStorageManager(storageConfig);
   const cache = createCacheManager({
-    cacheDir: config.cache?.cacheDir || ".fractary/codex/cache",
-    ...config.cache
+    cacheDir: codexConfig?.cacheDir || codexConfig?.cache?.cacheDir || ".fractary/codex/cache",
+    ...codexConfig?.cache || {}
   });
   if (storage) {
     cache.setStorageManager(storage);