@fractary/codex 0.3.1 → 0.5.0

package/dist/index.cjs

@@ -1,19 +1,119 @@
 'use strict';
 
+var micromatch3 = require('micromatch');
 var path3 = require('path');
 var child_process = require('child_process');
-var micromatch3 = require('micromatch');
 var zod = require('zod');
 var yaml = require('js-yaml');
 var fs2 = require('fs/promises');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var path3__default = /*#__PURE__*/_interopDefault(path3);
 var micromatch3__default = /*#__PURE__*/_interopDefault(micromatch3);
+var path3__default = /*#__PURE__*/_interopDefault(path3);
 var yaml__default = /*#__PURE__*/_interopDefault(yaml);
 var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function matchPattern(pattern, value) {
+  if (pattern === value) return true;
+  return micromatch3__default.default.isMatch(value, pattern);
+}
+function matchAnyPattern(patterns, value) {
+  if (patterns.length === 1 && patterns[0] === "*") {
+    return true;
+  }
+  if (patterns.length === 0) {
+    return false;
+  }
+  return patterns.some((pattern) => matchPattern(pattern, value));
+}
+function filterByPatterns(patterns, values) {
+  return values.filter((value) => matchAnyPattern(patterns, value));
+}
+function evaluatePatterns(options) {
+  const { value, include = [], exclude = [] } = options;
+  if (exclude.length > 0 && matchAnyPattern(exclude, value)) {
+    return false;
+  }
+  if (include.length === 0) {
+    return true;
+  }
+  return matchAnyPattern(include, value);
+}
+var init_matcher = __esm({
+  "src/core/patterns/matcher.ts"() {
+  }
+});
+
+// src/sync/directional-patterns.ts
+var directional_patterns_exports = {};
+__export(directional_patterns_exports, {
+  expandPlaceholders: () => expandPlaceholders,
+  extractProjectFromCodexPath: () => extractProjectFromCodexPath,
+  getRelativePath: () => getRelativePath,
+  matchFromCodexPattern: () => matchFromCodexPattern,
+  matchToCodexPattern: () => matchToCodexPattern
+});
+function matchToCodexPattern(filePath, patterns) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  return patterns.some((pattern) => matchPattern(pattern, filePath));
+}
+function matchFromCodexPattern(codexFilePath, patterns, targetProject) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+  return patterns.some((pattern) => {
+    const projectSeparatorIndex = pattern.indexOf("/");
+    if (projectSeparatorIndex === -1) {
+      const fullPattern = `${targetProject}/${pattern}`;
+      return matchPattern(fullPattern, codexFilePath);
+    }
+    const firstSegment = pattern.substring(0, projectSeparatorIndex);
+    if (firstSegment.includes(".")) {
+      return matchPattern(pattern, codexFilePath);
+    } else {
+      const fullPattern = `${targetProject}/${pattern}`;
+      return matchPattern(fullPattern, codexFilePath);
+    }
+  });
+}
+function extractProjectFromCodexPath(codexFilePath) {
+  const firstSlashIndex = codexFilePath.indexOf("/");
+  if (firstSlashIndex === -1) {
+    return null;
+  }
+  return codexFilePath.substring(0, firstSlashIndex);
+}
+function getRelativePath(codexFilePath) {
+  const firstSlashIndex = codexFilePath.indexOf("/");
+  if (firstSlashIndex === -1) {
+    return null;
+  }
+  return codexFilePath.substring(firstSlashIndex + 1);
+}
+function expandPlaceholders(patterns, targetProject) {
+  if (!patterns) {
+    return patterns;
+  }
+  return patterns.map((pattern) => pattern.replace(/{project}/g, targetProject));
+}
+var init_directional_patterns = __esm({
+  "src/sync/directional-patterns.ts"() {
+    init_matcher();
+  }
+});
+
 // src/errors/CodexError.ts
 var CodexError = class _CodexError extends Error {
   constructor(message, options) {
@@ -730,6 +830,16 @@ var SyncRulesSchema = zod.z.object({
   defaultInclude: zod.z.array(zod.z.string()).optional(),
   defaultExclude: zod.z.array(zod.z.string()).optional()
 });
+var DirectionalSyncSchema = zod.z.object({
+  // Patterns for files to push from this project to codex
+  to_codex: zod.z.array(zod.z.string()).optional(),
+  // Patterns for files to pull from codex to this project
+  // Format: "project-name/path/pattern" or "project-name/**"
+  from_codex: zod.z.array(zod.z.string()).optional(),
+  // Org-level defaults (only in codex repository config)
+  default_to_codex: zod.z.array(zod.z.string()).optional(),
+  default_from_codex: zod.z.array(zod.z.string()).optional()
+});
 var CodexConfigSchema = zod.z.object({
   organizationSlug: zod.z.string(),
   directories: zod.z.object({
@@ -737,7 +847,9 @@ var CodexConfigSchema = zod.z.object({
     target: zod.z.string().optional(),
     systems: zod.z.string().optional()
   }).optional(),
-  rules: SyncRulesSchema.optional()
+  rules: SyncRulesSchema.optional(),
+  // Directional sync configuration
+  sync: DirectionalSyncSchema.optional()
 }).strict();
 function parseMetadata(content, options = {}) {
   const { strict = true, normalize = true } = options;
@@ -785,6 +897,12 @@ function normalizeLegacyMetadata(parsed) {
   if (parsed.codex?.excludes && !parsed.codex_sync_exclude) {
     normalized.codex_sync_exclude = parsed.codex.excludes;
   }
+  if (parsed.codex_sync_includes && !normalized.codex_sync_include) {
+    normalized.codex_sync_include = parsed.codex_sync_includes;
+  }
+  if (parsed.codex_sync_excludes && !normalized.codex_sync_exclude) {
+    normalized.codex_sync_exclude = parsed.codex_sync_excludes;
+  }
   return normalized;
 }
 function hasFrontmatter(content) {
@@ -806,32 +924,9 @@ function extractRawFrontmatter(content) {
   const match = normalized.match(/^---\n([\s\S]*?)\n---\n/);
   return match && match[1] ? match[1] : null;
 }
-function matchPattern(pattern, value) {
-  if (pattern === value) return true;
-  return micromatch3__default.default.isMatch(value, pattern);
-}
-function matchAnyPattern(patterns, value) {
-  if (patterns.length === 1 && patterns[0] === "*") {
-    return true;
-  }
-  if (patterns.length === 0) {
-    return false;
-  }
-  return patterns.some((pattern) => matchPattern(pattern, value));
-}
-function filterByPatterns(patterns, values) {
-  return values.filter((value) => matchAnyPattern(patterns, value));
-}
-function evaluatePatterns(options) {
-  const { value, include = [], exclude = [] } = options;
-  if (exclude.length > 0 && matchAnyPattern(exclude, value)) {
-    return false;
-  }
-  if (include.length === 0) {
-    return true;
-  }
-  return matchAnyPattern(include, value);
-}
+
+// src/core/patterns/index.ts
+init_matcher();
 
 // src/core/config/organization.ts
 function resolveOrganization(options = {}) {
@@ -942,11 +1037,24 @@ function mergeConfigs(base, override) {
       autoSyncPatterns: override.rules?.autoSyncPatterns ?? base.rules?.autoSyncPatterns,
       defaultInclude: override.rules?.defaultInclude ?? base.rules?.defaultInclude,
       defaultExclude: override.rules?.defaultExclude ?? base.rules?.defaultExclude
-    }
+    },
+    // Only include sync if either base or override has sync config
+    ...base.sync || override.sync ? {
+      sync: {
+        ...base.sync,
+        ...override.sync,
+        // Arrays are replaced, not merged
+        to_codex: override.sync?.to_codex ?? base.sync?.to_codex,
+        from_codex: override.sync?.from_codex ?? base.sync?.from_codex,
+        default_to_codex: override.sync?.default_to_codex ?? base.sync?.default_to_codex,
+        default_from_codex: override.sync?.default_from_codex ?? base.sync?.default_from_codex
+      }
+    } : {}
   };
 }
 
 // src/core/routing/evaluator.ts
+init_matcher();
 function shouldSyncToRepo(options) {
   const {
     filePath,
@@ -2720,9 +2828,10 @@ async function scanCodexWithRouting(options) {
     org,
     rules,
     storage,
-    skipNoFrontmatter = true,
-    maxFileSize = 10 * 1024 * 1024
+    skipNoFrontmatter = false,
+    maxFileSize = 10 * 1024 * 1024,
     // 10MB default
+    fromCodexPatterns
   } = options;
   const startTime = Date.now();
   const routedFiles = [];
@@ -2730,14 +2839,17 @@ async function scanCodexWithRouting(options) {
   const errors = [];
   let totalScanned = 0;
   let totalSkipped = 0;
+  let expandedFromCodexPatterns = fromCodexPatterns;
+  let matchFromCodexPattern2 = null;
+  if (fromCodexPatterns && fromCodexPatterns.length > 0) {
+    const module = await Promise.resolve().then(() => (init_directional_patterns(), directional_patterns_exports));
+    matchFromCodexPattern2 = module.matchFromCodexPattern;
+    expandedFromCodexPatterns = module.expandPlaceholders(fromCodexPatterns, targetProject);
+  }
   const allFiles = await listAllFilesRecursive(codexDir);
   for (const filePath of allFiles) {
     totalScanned++;
     try {
-      if (!filePath.endsWith(".md")) {
-        totalSkipped++;
-        continue;
-      }
       const fullPath = path3__default.default.join(codexDir, filePath);
       const stats = await fs2__default.default.stat(fullPath);
       if (stats.size > maxFileSize) {
@@ -2750,18 +2862,23 @@ async function scanCodexWithRouting(options) {
       }
       const content = await storage.readText(fullPath);
       const parseResult = parseMetadata(content, { strict: false });
-      if (skipNoFrontmatter && Object.keys(parseResult.metadata).length === 0) {
+      if (!matchFromCodexPattern2 && skipNoFrontmatter && Object.keys(parseResult.metadata).length === 0) {
         totalSkipped++;
         continue;
       }
       const sourceProject = extractProjectFromPath(filePath, org);
-      const shouldSync = shouldSyncToRepo({
-        filePath,
-        fileMetadata: parseResult.metadata,
-        targetRepo: targetProject,
-        sourceRepo: sourceProject,
-        rules
-      });
+      let shouldSync = false;
+      if (matchFromCodexPattern2 && expandedFromCodexPatterns && expandedFromCodexPatterns.length > 0) {
+        shouldSync = matchFromCodexPattern2(filePath, expandedFromCodexPatterns, targetProject);
+      } else {
+        shouldSync = shouldSyncToRepo({
+          filePath,
+          fileMetadata: parseResult.metadata,
+          targetRepo: targetProject,
+          sourceRepo: sourceProject,
+          rules
+        });
+      }
       if (shouldSync) {
         const buffer = Buffer.from(content);
         const hash = calculateContentHash(buffer);
@@ -2912,7 +3029,16 @@ var SyncManager = class {
    * @param options - Sync options
    */
   async createPlan(_org, _project, sourceDir, targetFiles, options) {
-    const sourceFiles = await this.listLocalFiles(sourceDir);
+    let sourceFiles = await this.listLocalFiles(sourceDir);
+    if (options?.direction === "to-codex") {
+      const toCodexPatterns = this.config.to_codex || this.config.default_to_codex;
+      if (toCodexPatterns) {
+        const { matchToCodexPattern: matchToCodexPattern2 } = await Promise.resolve().then(() => (init_directional_patterns(), directional_patterns_exports));
+        sourceFiles = sourceFiles.filter(
+          (file) => matchToCodexPattern2(file.path, toCodexPatterns)
+        );
+      }
+    }
     const plan = createSyncPlan(
       sourceFiles,
       targetFiles,
@@ -2950,13 +3076,16 @@ var SyncManager = class {
    * ```
    */
   async createRoutingAwarePlan(org, project, codexDir, options) {
+    const fromCodexPatterns = this.config.from_codex || this.config.default_from_codex;
     const routingScan = await scanCodexWithRouting({
       codexDir,
       targetProject: project,
       org,
       rules: void 0,
       // Use default routing rules (preventSelfSync, preventCodexSync, etc.)
-      storage: this.localStorage
+      storage: this.localStorage,
+      fromCodexPatterns
+      // Use directional patterns if configured
     });
     const sourceFiles = routingScan.files.map((rf) => ({
       path: rf.path,
@@ -2965,7 +3094,15 @@ var SyncManager = class {
       hash: rf.hash
     }));
     const targetFiles = await this.listLocalFiles(process.cwd());
-    const plan = createSyncPlan(sourceFiles, targetFiles, options ?? {}, this.config);
+    const planOptions = {
+      direction: options?.direction,
+      force: options?.force,
+      dryRun: options?.dryRun
+      // Explicitly exclude include/exclude to prevent double filtering
+      // include: undefined,
+      // exclude: undefined,
+    };
+    const plan = createSyncPlan(sourceFiles, targetFiles, planOptions, this.config);
     plan.estimatedTime = estimateSyncTime(plan);
     return {
       ...plan,