@fractary/codex 0.5.1 → 0.7.0

package/dist/index.d.cts

@@ -870,16 +870,24 @@ interface SyncRule {
     priority?: number;
     direction?: SyncDirection;
 }
+interface DirectionalSyncConfig {
+    include: string[];
+    exclude?: string[];
+}
+interface RoutingConfig {
+    use_frontmatter?: boolean;
+}
 interface SyncConfig {
     defaultDirection: SyncDirection;
     rules: SyncRule[];
     defaultExcludes: string[];
     deleteOrphans: boolean;
     conflictStrategy: 'newest' | 'local' | 'remote' | 'manual';
-    to_codex?: string[];
-    from_codex?: string[];
-    default_to_codex?: string[];
+    from_codex?: DirectionalSyncConfig;
+    to_codex?: DirectionalSyncConfig;
+    routing?: RoutingConfig;
     default_from_codex?: string[];
+    default_to_codex?: string[];
     exclude?: string[];
 }
 declare const DEFAULT_SYNC_CONFIG: SyncConfig;
@@ -960,6 +968,8 @@ declare class SyncManager {
     private manifestPath;
     private manifest;
     constructor(options: SyncManagerConfig);
+    private resolveFromCodexPatterns;
+    private resolveToCodexPatterns;
     loadManifest(): Promise<SyncManifest | null>;
     saveManifest(manifest: SyncManifest): Promise<void>;
     getOrCreateManifest(org: string, project: string): Promise<SyncManifest>;

package/dist/index.d.ts

@@ -870,16 +870,24 @@ interface SyncRule {
     priority?: number;
     direction?: SyncDirection;
 }
+interface DirectionalSyncConfig {
+    include: string[];
+    exclude?: string[];
+}
+interface RoutingConfig {
+    use_frontmatter?: boolean;
+}
 interface SyncConfig {
     defaultDirection: SyncDirection;
     rules: SyncRule[];
     defaultExcludes: string[];
     deleteOrphans: boolean;
     conflictStrategy: 'newest' | 'local' | 'remote' | 'manual';
-    to_codex?: string[];
-    from_codex?: string[];
-    default_to_codex?: string[];
+    from_codex?: DirectionalSyncConfig;
+    to_codex?: DirectionalSyncConfig;
+    routing?: RoutingConfig;
     default_from_codex?: string[];
+    default_to_codex?: string[];
     exclude?: string[];
 }
 declare const DEFAULT_SYNC_CONFIG: SyncConfig;
@@ -960,6 +968,8 @@ declare class SyncManager {
     private manifestPath;
     private manifest;
     constructor(options: SyncManagerConfig);
+    private resolveFromCodexPatterns;
+    private resolveToCodexPatterns;
     loadManifest(): Promise<SyncManifest | null>;
     saveManifest(manifest: SyncManifest): Promise<void>;
     getOrCreateManifest(org: string, project: string): Promise<SyncManifest>;

package/dist/index.js

@@ -2855,16 +2855,24 @@ async function scanCodexWithRouting(options) {
         continue;
       }
       const content = await storage.readText(fullPath);
-      const parseResult = parseMetadata(content, { strict: false });
-      if (!matchFromCodexPattern2 && skipNoFrontmatter && Object.keys(parseResult.metadata).length === 0) {
-        totalSkipped++;
-        continue;
-      }
       const sourceProject = extractProjectFromPath(filePath, org);
       let shouldSync = false;
+      let parseResult = null;
+      const useFrontmatter = options.routing?.use_frontmatter === true;
       if (matchFromCodexPattern2 && expandedFromCodexPatterns && expandedFromCodexPatterns.length > 0) {
         shouldSync = matchFromCodexPattern2(filePath, expandedFromCodexPatterns, targetProject);
-      } else {
+        parseResult = parseMetadata(content, { strict: false });
+      } else if (useFrontmatter) {
+        parseResult = parseMetadata(content, { strict: false });
+        if (parseResult.metadata.codex_sync_include) {
+          console.warn(
+            `[DEPRECATION] File ${filePath} uses codex_sync_include frontmatter. This feature will be removed in v1.0. Use config.yaml patterns instead.`
+          );
+        }
+        if (skipNoFrontmatter && Object.keys(parseResult.metadata).length === 0) {
+          totalSkipped++;
+          continue;
+        }
         shouldSync = shouldSyncToRepo({
           filePath,
           fileMetadata: parseResult.metadata,
@@ -2872,6 +2880,9 @@ async function scanCodexWithRouting(options) {
           sourceRepo: sourceProject,
           rules
         });
+      } else {
+        totalSkipped++;
+        continue;
       }
       if (shouldSync) {
         const buffer = Buffer.from(content);
@@ -2881,7 +2892,7 @@ async function scanCodexWithRouting(options) {
           size: buffer.length,
           mtime: stats.mtimeMs,
           hash,
-          metadata: parseResult.metadata,
+          metadata: parseResult?.metadata ?? {},
           sourceProject
         });
         sourceProjectsSet.add(sourceProject);
@@ -2964,6 +2975,30 @@ var SyncManager = class {
     };
     this.manifestPath = options.manifestPath ?? ".fractary/codex-sync-manifest.json";
   }
+  /**
+   * Resolve from_codex include patterns (v0.7.0+)
+   *
+   * Supports both new format (from_codex.include) and legacy format (default_from_codex).
+   * New format takes precedence.
+   */
+  resolveFromCodexPatterns() {
+    if (this.config.from_codex?.include) {
+      return this.config.from_codex.include;
+    }
+    return this.config.default_from_codex || [];
+  }
+  /**
+   * Resolve to_codex include patterns (v0.7.0+)
+   *
+   * Supports both new format (to_codex.include) and legacy format (default_to_codex).
+   * New format takes precedence.
+   */
+  resolveToCodexPatterns() {
+    if (this.config.to_codex?.include) {
+      return this.config.to_codex.include;
+    }
+    return this.config.default_to_codex || [];
+  }
   /**
    * Load the sync manifest
    */
@@ -3033,8 +3068,8 @@ var SyncManager = class {
   async createPlan(_org, _project, sourceDir, targetFiles, options) {
     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 toCodexPatterns = this.resolveToCodexPatterns();
+      if (toCodexPatterns.length > 0) {
         const { matchToCodexPattern: matchToCodexPattern2 } = await Promise.resolve().then(() => (init_directional_patterns(), directional_patterns_exports));
         sourceFiles = sourceFiles.filter(
           (file) => matchToCodexPattern2(file.path, toCodexPatterns)
@@ -3078,7 +3113,7 @@ var SyncManager = class {
    * ```
    */
   async createRoutingAwarePlan(org, project, codexDir, options) {
-    const fromCodexPatterns = this.config.from_codex || this.config.default_from_codex;
+    const fromCodexPatterns = this.resolveFromCodexPatterns();
     const routingScan = await scanCodexWithRouting({
       codexDir,
       targetProject: project,
@@ -3086,8 +3121,9 @@ var SyncManager = class {
       rules: void 0,
       // Use default routing rules (preventSelfSync, preventCodexSync, etc.)
       storage: this.localStorage,
-      fromCodexPatterns
-      // Use directional patterns if configured
+      fromCodexPatterns: fromCodexPatterns.length > 0 ? fromCodexPatterns : void 0,
+      routing: this.config.routing
+      // Pass routing config for frontmatter control
     });
     const sourceFiles = routingScan.files.map((rf) => ({
       path: rf.path,
@@ -3106,16 +3142,19 @@ var SyncManager = class {
     };
     const plan = createSyncPlan(sourceFiles, targetFiles, planOptions, this.config);
     plan.estimatedTime = estimateSyncTime(plan);
+    plan.source = codexDir;
+    plan.target = ".fractary/codex/cache";
     return {
       ...plan,
       routingScan
     };
   }
   /**
-   * Execute a sync plan (dry run)
+   * Execute a sync plan
    *
-   * In a real implementation, this would actually copy files.
-   * For the SDK, we provide the plan and let consumers execute.
+   * Copies files from source to target based on the plan.
+   * For from-codex syncs, files are copied to .fractary/codex/cache/ preserving full paths.
+   * For to-codex syncs, files are copied to the codex repository.
    */
   async executePlan(plan, options) {
     const startTime = Date.now();
@@ -3141,7 +3180,30 @@ var SyncManager = class {
         if (options?.onProgress) {
           options.onProgress(i + 1, plan.totalFiles, file.path);
         }
-        synced++;
+        if (file.operation === "create" || file.operation === "update") {
+          const sourcePath = `${plan.source}/${file.path}`;
+          const targetPath = `${plan.target}/${file.path}`;
+          const fs4 = await import('fs/promises');
+          const path6 = await import('path');
+          const targetDir = path6.dirname(targetPath);
+          await fs4.mkdir(targetDir, { recursive: true });
+          await fs4.copyFile(sourcePath, targetPath);
+          synced++;
+        } else if (file.operation === "delete") {
+          const targetPath = `${plan.target}/${file.path}`;
+          const fs4 = await import('fs/promises');
+          try {
+            await fs4.unlink(targetPath);
+            synced++;
+          } catch (error) {
+            if (error.code !== "ENOENT") {
+              throw error;
+            }
+            synced++;
+          }
+        } else {
+          synced++;
+        }
       } catch (error) {
         failed++;
         errors.push({