@dezkareid/ai-context-sync 1.3.0 → 1.5.0

package/README.md

@@ -48,15 +48,62 @@ To bypass reading or creating this configuration file, use the `--skip-config` f
 npx @dezkareid/ai-context-sync sync --skip-config
 ```
 
+### Monorepo / Multi-project Sync
+
+In complex projects or monorepos, you can configure multiple subdirectories to be synchronized in a single command. The tool will sequentially sync the root project and then each configured subdirectory.
+
+#### Managing Projects
+
+Use the `project` command to manage your configured projects:
+
+```bash
+# Add a new project (interactive)
+npx @dezkareid/ai-context-sync project add apps/web
+
+# Add a project with specific strategies
+npx @dezkareid/ai-context-sync project add packages/ui --strategy "claude, gemini"
+
+# Add a project with custom files
+npx @dezkareid/ai-context-sync project add packages/lib --strategy other --files "CUSTOM.md"
+```
+
+#### Configuration Structure
+
+Configured projects are stored in the `.ai-context-configrc` file at the root:
+
+```json
+{
+  "strategies": ["claude"],
+  "projects": {
+    "apps/web": {
+      "strategies": ["gemini"]
+    },
+    "packages/ui": {
+      "strategies": ["claude", "gemini"]
+    }
+  }
+}
+```
+
+When you run `npx @dezkareid/ai-context-sync sync`, it will:
+1. Sync the root using the top-level `strategies`.
+2. Sync `apps/web` using the `gemini` strategy.
+3. Sync `packages/ui` using `claude` and `gemini` strategies.
+
+If a project doesn't define its own `strategies`, it will inherit the root's `strategies`.
+
+
 ### Directory option
 
+The `-d, --dir` option allows you to specify where the root `AGENTS.md` and configuration file live. All project paths are resolved relative to this directory.
+
 ## How it works
 
-1. The tool looks for an `AGENTS.md` file in the target directory.
+1. The tool looks for an `AGENTS.md` file in the target directory (root and each configured project).
 2. It reads the content of `AGENTS.md`.
-3. It applies different strategies to update provider-specific files:
-   - **Claude**: Creates a symbolic link `CLAUDE.md` pointing to `AGENTS.md`.
-   - **Gemini**: Updates `.gemini/settings.json` to include `AGENTS.md` in the `context.fileName` list.
+3. It applies different strategies sequentially.
+4. If a specific synchronization fails, it reports the error but continues with the next project (fail-soft).
+5. A summary is displayed at the end if any errors occurred.
 
 ## License
 

package/dist/constants.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONFIG_FILENAME = exports.AGENTS_FILENAME = void 0;
-exports.AGENTS_FILENAME = 'AGENTS.md';
-exports.CONFIG_FILENAME = '.ai-context-configrc';
+export const AGENTS_FILENAME = 'AGENTS.md';
+export const CONFIG_FILENAME = '.ai-context-configrc';

package/dist/engine.js

@@ -1,54 +1,53 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncEngine = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const constants_js_1 = require("./constants.js");
-const claude_js_1 = require("./strategies/claude.js");
-const gemini_js_1 = require("./strategies/gemini.js");
-const gemini_md_js_1 = require("./strategies/gemini-md.js");
-const other_js_1 = require("./strategies/other.js");
-class SyncEngine {
+import fs from 'fs-extra';
+import path from 'path';
+import { AGENTS_FILENAME } from './constants.js';
+import { ClaudeStrategy } from './strategies/claude.js';
+import { GeminiStrategy } from './strategies/gemini.js';
+import { GeminiMdStrategy } from './strategies/gemini-md.js';
+import { OtherStrategy } from './strategies/other.js';
+function buildBuiltInStrategies(fromFile) {
+    return [
+        new ClaudeStrategy(fromFile),
+        new GeminiStrategy(fromFile),
+        new GeminiMdStrategy(fromFile)
+    ];
+}
+function resolveStrategiesToRun(selectedStrategies, builtInStrategies, otherFiles, fromFile) {
+    if (!selectedStrategies || (Array.isArray(selectedStrategies) && selectedStrategies.length === 0)) {
+        return builtInStrategies;
+    }
+    const selectedList = Array.isArray(selectedStrategies) ? selectedStrategies : [selectedStrategies];
+    const normalizedList = selectedList.map(s => s.toLowerCase());
+    let strategies;
+    if (normalizedList.includes('all') || normalizedList.includes('both')) {
+        strategies = [...builtInStrategies];
+    }
+    else {
+        strategies = builtInStrategies.filter(s => normalizedList.includes(s.name.toLowerCase()));
+    }
+    if (normalizedList.includes('other')) {
+        if (!otherFiles || otherFiles.length === 0) {
+            throw new Error('Strategy "other" requires otherFiles to be specified.');
+        }
+        for (const filename of otherFiles) {
+            strategies.push(new OtherStrategy(filename, fromFile));
+        }
+    }
+    return strategies;
+}
+export class SyncEngine {
     async sync(projectRoot, selectedStrategies, targetDir, fromFile, otherFiles) {
-        const sourceFile = fromFile ?? constants_js_1.AGENTS_FILENAME;
-        const agentsPath = path_1.default.join(projectRoot, sourceFile);
+        const sourceFile = fromFile ?? AGENTS_FILENAME;
+        const agentsPath = path.join(projectRoot, sourceFile);
         const outputDir = targetDir ?? projectRoot;
-        if (!(await fs_extra_1.default.pathExists(agentsPath))) {
+        if (!(await fs.pathExists(agentsPath))) {
             throw new Error(`${sourceFile} not found in ${projectRoot}`);
         }
-        const context = await fs_extra_1.default.readFile(agentsPath, 'utf-8');
-        const builtInStrategies = [
-            new claude_js_1.ClaudeStrategy(fromFile),
-            new gemini_js_1.GeminiStrategy(fromFile),
-            new gemini_md_js_1.GeminiMdStrategy(fromFile)
-        ];
-        let strategiesToRun;
-        if (!selectedStrategies || (Array.isArray(selectedStrategies) && selectedStrategies.length === 0)) {
-            strategiesToRun = builtInStrategies;
-        }
-        else {
-            const selectedList = Array.isArray(selectedStrategies) ? selectedStrategies : [selectedStrategies];
-            const normalizedList = selectedList.map(s => s.toLowerCase());
-            if (normalizedList.includes('all') || normalizedList.includes('both')) {
-                strategiesToRun = builtInStrategies;
-            }
-            else {
-                strategiesToRun = builtInStrategies.filter(s => normalizedList.includes(s.name.toLowerCase()));
-            }
-            if (normalizedList.includes('other')) {
-                if (!otherFiles || otherFiles.length === 0) {
-                    throw new Error('Strategy "other" requires otherFiles to be specified.');
-                }
-                for (const filename of otherFiles) {
-                    strategiesToRun.push(new other_js_1.OtherStrategy(filename, fromFile));
-                }
-            }
-        }
-        const availableNames = [...builtInStrategies.map(s => s.name), 'other'].join(', ');
+        const context = await fs.readFile(agentsPath, 'utf-8');
+        const builtInStrategies = buildBuiltInStrategies(fromFile);
+        const strategiesToRun = resolveStrategiesToRun(selectedStrategies, builtInStrategies, otherFiles, fromFile);
         if (strategiesToRun.length === 0 && selectedStrategies) {
+            const availableNames = [...builtInStrategies.map(s => s.name), 'other'].join(', ');
             throw new Error(`No valid strategies found for: ${selectedStrategies}. Available strategies: ${availableNames}`);
         }
         for (const strategy of strategiesToRun) {
@@ -57,4 +56,3 @@ class SyncEngine {
         }
     }
 }
-exports.SyncEngine = SyncEngine;

package/dist/index.js

@@ -1,128 +1,267 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const engine_js_1 = require("./engine.js");
-const path_1 = __importDefault(require("path"));
-const inquirer_1 = __importDefault(require("inquirer"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const constants_js_1 = require("./constants.js");
-const program = new commander_1.Command();
-program
-    .name('ai-context-sync')
-    .description('Sync AI context files across different providers')
-    .version('1.0.0');
-program
-    .command('sync')
-    .description('Synchronize context files from AGENTS.md')
-    .option('-d, --dir <path>', 'Project directory (where AGENTS.md lives)', process.cwd())
-    .option('-t, --target-dir <path>', 'Target directory where synced files will be written (defaults to --dir)')
-    .option('-s, --strategy <strategy>', 'Sync strategy (claude, gemini, all, or comma-separated list)')
-    .option('-f, --files <names>', 'Comma-separated custom filenames for "other" strategy')
-    .option('--from <path>', 'Source file path for symlinks (default: AGENTS.md)')
-    .option('--skip-config', 'Avoid reading/creating the config file', false)
-    .action(async (options) => {
+import { Command } from 'commander';
+import { SyncEngine } from './engine.js';
+import path from 'path';
+import inquirer from 'inquirer';
+import fs from 'fs-extra';
+import { CONFIG_FILENAME } from './constants.js';
+export async function readConfig(configPath) {
     try {
-        const projectRoot = path_1.default.resolve(options.dir);
-        const targetDir = options.targetDir ? path_1.default.resolve(options.targetDir) : projectRoot;
-        const configPath = path_1.default.join(projectRoot, constants_js_1.CONFIG_FILENAME);
-        let strategy = options.strategy;
-        let otherFiles;
-        let fromFile;
-        // 1. If no strategy provided, try to read from config
-        if (!options.skipConfig) {
-            if (await fs_extra_1.default.pathExists(configPath)) {
-                try {
-                    const config = await fs_extra_1.default.readJson(configPath);
-                    if (!strategy && config.strategies) {
-                        strategy = config.strategies;
-                    }
-                    if (config.otherFiles) {
-                        otherFiles = config.otherFiles;
-                    }
-                    if (config.from) {
-                        fromFile = config.from;
-                    }
-                }
-                catch (e) {
-                    // Ignore corrupted config and proceed to prompt
+        return await fs.readJson(configPath);
+    }
+    catch {
+        return {};
+    }
+}
+async function promptStrategies() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'strategies',
+            message: 'Select the AI context files to sync:',
+            choices: [
+                { name: 'Claude (CLAUDE.md)', value: 'claude', checked: true },
+                { name: 'Gemini (.gemini/settings.json)', value: 'gemini', checked: true },
+                { name: 'Gemini Markdown (GEMINI.md)', value: 'gemini-md', checked: true },
+                { name: 'Other (custom files)', value: 'other', checked: false }
+            ],
+            validate: (answer) => {
+                if (answer.length < 1) {
+                    return 'You must choose at least one strategy.';
                 }
+                return true;
             }
         }
-        // 2. Resolve --from flag (takes precedence over config)
-        if (options.from) {
-            if (path_1.default.isAbsolute(options.from)) {
-                throw new Error('--from must be a relative path, not an absolute path.');
-            }
-            fromFile = options.from;
-        }
-        // 3. Resolve --files flag (merge with config otherFiles)
-        if (options.files) {
-            const flagFiles = options.files.split(',').map((s) => s.trim()).filter(Boolean);
-            otherFiles = [...new Set([...(otherFiles ?? []), ...flagFiles])];
-        }
-        // 4. If still no strategy, prompt user
-        if (!strategy) {
-            const answers = await inquirer_1.default.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'strategies',
-                    message: 'Select the AI context files to sync:',
-                    choices: [
-                        { name: 'Claude (CLAUDE.md)', value: 'claude', checked: true },
-                        { name: 'Gemini (.gemini/settings.json)', value: 'gemini', checked: true },
-                        { name: 'Gemini Markdown (GEMINI.md)', value: 'gemini-md', checked: true },
-                        { name: 'Other (custom files)', value: 'other', checked: false }
-                    ],
-                    validate: (answer) => {
-                        if (answer.length < 1) {
-                            return 'You must choose at least one strategy.';
-                        }
-                        return true;
-                    }
-                }
-            ]);
-            strategy = answers.strategies;
-            // Follow-up prompt for custom filenames when 'other' is selected and not already set
-            if (strategy.includes('other') && (!otherFiles || otherFiles.length === 0)) {
-                const filesAnswer = await inquirer_1.default.prompt([
-                    {
-                        type: 'input',
-                        name: 'otherFiles',
-                        message: 'Enter custom file name(s) to create as symlinks (comma-separated):',
-                        validate: (v) => v.trim().length > 0 || 'At least one filename is required.'
-                    }
-                ]);
-                otherFiles = filesAnswer.otherFiles.split(',').map((s) => s.trim()).filter(Boolean);
-            }
+    ]);
+    return answers.strategies;
+}
+async function promptOtherFiles() {
+    const filesAnswer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'otherFiles',
+            message: 'Enter custom file name(s) to create as symlinks (comma-separated):',
+            validate: (v) => v.trim().length > 0 || 'At least one filename is required.'
         }
-        else if (typeof strategy === 'string') {
-            strategy = strategy.split(',').map(s => s.trim());
+    ]);
+    return filesAnswer.otherFiles.split(',').map((s) => s.trim()).filter(Boolean);
+}
+async function resolveStrategy(strategyOption, otherFiles) {
+    if (!strategyOption) {
+        const selected = await promptStrategies();
+        let resolved = [...(otherFiles ?? [])];
+        if (selected.includes('other') && resolved.length === 0) {
+            resolved = await promptOtherFiles();
         }
-        // 5. Validate: if 'other' strategy selected but no otherFiles resolved
-        if (Array.isArray(strategy) && strategy.includes('other') && (!otherFiles || otherFiles.length === 0)) {
-            throw new Error('Strategy "other" requires --files or a saved "otherFiles" config entry.');
+        return { strategy: selected, otherFiles: resolved.length > 0 ? resolved : otherFiles };
+    }
+    const strategy = typeof strategyOption === 'string'
+        ? strategyOption.split(',').map(s => s.trim())
+        : strategyOption;
+    return { strategy, otherFiles };
+}
+async function applyConfig(options, configPath) {
+    let strategy = options.strategy;
+    let otherFiles;
+    let fromFile;
+    let config = {};
+    if (!options.skipConfig && await fs.pathExists(configPath)) {
+        config = await readConfig(configPath);
+        if (!strategy && config.strategies) {
+            strategy = config.strategies;
         }
-        // 6. Save strategy to config if not skipping
+        otherFiles = config.otherFiles;
+        fromFile = config.from;
+    }
+    return { config, strategy, otherFiles, fromFile };
+}
+function resolveFromFile(optionFrom, configFromFile) {
+    if (!optionFrom)
+        return configFromFile;
+    if (path.isAbsolute(optionFrom)) {
+        throw new Error('--from must be a relative path, not an absolute path.');
+    }
+    return optionFrom;
+}
+function mergeOtherFiles(optionFiles, configOtherFiles) {
+    if (!optionFiles)
+        return configOtherFiles;
+    const flagFiles = optionFiles.split(',').map((s) => s.trim()).filter(Boolean);
+    return [...new Set([...(configOtherFiles ?? []), ...flagFiles])];
+}
+export async function resolveProjectConfig(projectPath, rootConfig, overrides) {
+    const configPath = path.join(projectPath, CONFIG_FILENAME);
+    const localConfig = await readConfig(configPath);
+    const strategy = overrides?.strategies ?? localConfig.strategies ?? rootConfig.strategies;
+    const otherFiles = overrides?.otherFiles ?? localConfig.otherFiles ?? rootConfig.otherFiles;
+    const fromFile = overrides?.from ?? localConfig.from ?? rootConfig.from;
+    const strategyArray = typeof strategy === 'string'
+        ? strategy.split(',').map(s => s.trim())
+        : (strategy ?? []);
+    return {
+        strategy: strategyArray,
+        otherFiles,
+        fromFile
+    };
+}
+async function syncProject(projectRoot, strategy, targetDir, fromFile, otherFiles, projectName) {
+    if (strategy.includes('other') && (!otherFiles || otherFiles.length === 0)) {
+        throw new Error('Strategy "other" requires custom files to be defined.');
+    }
+    const engine = new SyncEngine();
+    await engine.sync(projectRoot, strategy, targetDir, fromFile, otherFiles);
+    console.log(`[${projectName}] Successfully synchronized using "${strategy.join(', ')}"!`);
+}
+async function runRootSync(options, config, projectRoot, configPath, configResult) {
+    try {
+        const fromFile = resolveFromFile(options.from, configResult.fromFile);
+        const otherFiles = mergeOtherFiles(options.files, configResult.otherFiles);
+        const resolved = await resolveStrategy(configResult.strategy, otherFiles);
+        await syncProject(projectRoot, resolved.strategy, options.targetDir ? path.resolve(options.targetDir) : projectRoot, fromFile, resolved.otherFiles, 'root');
         if (!options.skipConfig) {
-            const configData = { strategies: strategy };
-            if (otherFiles?.length)
-                configData.otherFiles = otherFiles;
+            const configData = { ...config, strategies: resolved.strategy };
+            if (resolved.otherFiles?.length)
+                configData.otherFiles = resolved.otherFiles;
             if (fromFile)
                 configData.from = fromFile;
-            await fs_extra_1.default.writeJson(configPath, configData, { spaces: 2 });
+            await fs.writeJson(configPath, configData, { spaces: 2 });
         }
-        const engine = new engine_js_1.SyncEngine();
-        await engine.sync(projectRoot, strategy, targetDir, fromFile, otherFiles);
-        const strategyMsg = Array.isArray(strategy) ? strategy.join(', ') : strategy;
-        console.log(`Successfully synchronized context files using "${strategyMsg}"!`);
+        return { name: 'root', success: true };
     }
     catch (error) {
-        console.error(`Error: ${error.message}`);
-        process.exit(1);
+        return { name: 'root', success: false, error: error instanceof Error ? error.message : String(error) };
     }
-});
-program.parse();
+}
+async function runProjectsSync(config, projectRoot) {
+    const results = [];
+    if (!config.projects)
+        return results;
+    for (const [projectPath, projectOverrides] of Object.entries(config.projects)) {
+        try {
+            const absoluteProjectPath = path.resolve(projectRoot, projectPath);
+            if (!(await fs.pathExists(absoluteProjectPath))) {
+                throw new Error(`Project path does not exist: ${projectPath}`);
+            }
+            const resolved = await resolveProjectConfig(absoluteProjectPath, config, projectOverrides);
+            await syncProject(absoluteProjectPath, resolved.strategy, absoluteProjectPath, resolved.fromFile, resolved.otherFiles, projectPath);
+            results.push({ name: projectPath, success: true });
+        }
+        catch (error) {
+            results.push({ name: projectPath, success: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return results;
+}
+function displaySummary(results) {
+    const failures = results.filter(r => !r.success);
+    if (failures.length > 0) {
+        console.warn('\n--- Synchronization Summary ---');
+        console.warn(`Success: ${results.length - failures.length}/${results.length}`);
+        console.warn('Failures:');
+        failures.forEach(f => console.warn(`  - [${f.name}]: ${f.error}`));
+        if (failures.length === results.length) {
+            throw new Error('All synchronizations failed.');
+        }
+    }
+    else if (results.length > 0) {
+        console.log('\nAll projects synchronized successfully!');
+    }
+}
+async function runSync(options) {
+    const projectRoot = path.resolve(options.dir);
+    const configPath = path.join(projectRoot, CONFIG_FILENAME);
+    const configResult = await applyConfig(options, configPath);
+    const results = [];
+    const rootResult = await runRootSync(options, configResult.config, projectRoot, configPath, configResult);
+    results.push(rootResult);
+    const projectResults = await runProjectsSync(configResult.config, projectRoot);
+    results.push(...projectResults);
+    displaySummary(results);
+}
+export async function addProject(projectPath, options) {
+    const projectRoot = path.resolve(options.dir);
+    const configPath = path.join(projectRoot, CONFIG_FILENAME);
+    const config = await readConfig(configPath);
+    const relativePath = path.isAbsolute(projectPath)
+        ? path.relative(projectRoot, projectPath)
+        : projectPath;
+    const absoluteProjectPath = path.resolve(projectRoot, relativePath);
+    if (!(await fs.pathExists(absoluteProjectPath))) {
+        console.warn(`Warning: Project path does not exist: ${absoluteProjectPath}`);
+    }
+    const otherFiles = options.files ? options.files.split(',').map(s => s.trim()) : undefined;
+    const strategies = options.strategy ? options.strategy.split(',').map(s => s.trim()) : undefined;
+    let resolvedStrategies = strategies;
+    let resolvedOtherFiles = otherFiles;
+    if (!strategies) {
+        const resolved = await resolveStrategy(undefined, undefined);
+        resolvedStrategies = resolved.strategy;
+        resolvedOtherFiles = resolved.otherFiles;
+    }
+    const projectConfig = {};
+    if (resolvedStrategies)
+        projectConfig.strategies = resolvedStrategies;
+    if (resolvedOtherFiles)
+        projectConfig.otherFiles = resolvedOtherFiles;
+    if (options.from)
+        projectConfig.from = options.from;
+    const newConfig = {
+        ...config,
+        projects: {
+            ...(config.projects || {}),
+            [relativePath]: projectConfig
+        }
+    };
+    await fs.writeJson(configPath, newConfig, { spaces: 2 });
+    console.log(`Successfully added project "${relativePath}" to configuration.`);
+}
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('ai-context-sync')
+        .description('Sync AI context files across different providers')
+        .version('1.0.0');
+    const projectCommand = program.command('project').description('Manage configured projects');
+    projectCommand
+        .command('add <path>')
+        .description('Add a new project to the configuration')
+        .option('-d, --dir <path>', 'Root project directory', process.cwd())
+        .option('-s, --strategy <strategy>', 'Sync strategy for this project')
+        .option('-f, --files <names>', 'Custom filenames for "other" strategy')
+        .option('--from <path>', 'Source file path for symlinks')
+        .action(async (projectPath, options) => {
+        try {
+            await addProject(projectPath, options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${message}`);
+            process.exit(1);
+        }
+    });
+    program
+        .command('sync')
+        .description('Synchronize context files from AGENTS.md')
+        .option('-d, --dir <path>', 'Project directory (where AGENTS.md lives)', process.cwd())
+        .option('-t, --target-dir <path>', 'Target directory where synced files will be written (defaults to --dir)')
+        .option('-s, --strategy <strategy>', 'Sync strategy (claude, gemini, all, or comma-separated list)')
+        .option('-f, --files <names>', 'Comma-separated custom filenames for "other" strategy')
+        .option('--from <path>', 'Source file path for symlinks (default: AGENTS.md)')
+        .option('--skip-config', 'Avoid reading/creating the config file', false)
+        .action(async (options) => {
+        try {
+            await runSync(options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${message}`);
+            process.exit(1);
+        }
+    });
+    return program;
+}
+if (process.argv[1] && (process.argv[1].endsWith('dist/index.js') ||
+    process.argv[1].endsWith('bin/ai-context-sync') ||
+    (fs.existsSync(path.resolve('dist/index.js')) && fs.realpathSync(process.argv[1]) === fs.realpathSync(path.resolve('dist/index.js'))))) {
+    createProgram().parse();
+}

package/dist/strategies/claude.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeStrategy = void 0;
-const symlink_js_1 = require("./symlink.js");
-class ClaudeStrategy extends symlink_js_1.SymlinkStrategy {
+import { SymlinkStrategy } from './symlink.js';
+export class ClaudeStrategy extends SymlinkStrategy {
     name = 'claude';
     targetFilename = 'CLAUDE.md';
     constructor(fromFile) {
         super(fromFile);
     }
 }
-exports.ClaudeStrategy = ClaudeStrategy;

package/dist/strategies/gemini-md.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeminiMdStrategy = void 0;
-const symlink_js_1 = require("./symlink.js");
-class GeminiMdStrategy extends symlink_js_1.SymlinkStrategy {
+import { SymlinkStrategy } from './symlink.js';
+export class GeminiMdStrategy extends SymlinkStrategy {
     name = 'gemini-md';
     targetFilename = 'GEMINI.md';
     constructor(fromFile) {
         super(fromFile);
     }
 }
-exports.GeminiMdStrategy = GeminiMdStrategy;

package/dist/strategies/gemini.js

@@ -1,34 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeminiStrategy = void 0;
-const index_js_1 = require("./index.js");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-class GeminiStrategy {
+import { AGENTS_FILE } from './index.js';
+import fs from 'fs-extra';
+import path from 'path';
+export class GeminiStrategy {
     name = 'gemini';
     fromFile;
-    constructor(fromFile = index_js_1.AGENTS_FILE) {
+    constructor(fromFile = AGENTS_FILE) {
         this.fromFile = fromFile;
     }
     async sync(_context, projectRoot, targetDir) {
         const outputDir = targetDir ?? projectRoot;
-        const geminiDir = path_1.default.join(outputDir, '.gemini');
-        const settingsPath = path_1.default.join(geminiDir, 'settings.json');
+        const geminiDir = path.join(outputDir, '.gemini');
+        const settingsPath = path.join(geminiDir, 'settings.json');
         // Compute the path to the source file relative to the target .gemini directory
-        const agentsAbsPath = path_1.default.join(projectRoot, this.fromFile);
-        const agentsRelativePath = path_1.default.relative(outputDir, agentsAbsPath);
-        await fs_extra_1.default.ensureDir(geminiDir);
+        const agentsAbsPath = path.join(projectRoot, this.fromFile);
+        const agentsRelativePath = path.relative(outputDir, agentsAbsPath);
+        await fs.ensureDir(geminiDir);
         let settings = {};
         let exists = false;
-        if (await fs_extra_1.default.pathExists(settingsPath)) {
+        if (await fs.pathExists(settingsPath)) {
             exists = true;
             try {
-                settings = await fs_extra_1.default.readJson(settingsPath);
+                settings = await fs.readJson(settingsPath);
             }
-            catch (e) {
+            catch {
                 settings = {};
             }
         }
@@ -54,8 +48,7 @@ class GeminiStrategy {
             modified = true;
         }
         if (modified || !exists) {
-            await fs_extra_1.default.writeJson(settingsPath, settings, { spaces: 2 });
+            await fs.writeJson(settingsPath, settings, { spaces: 2 });
         }
     }
 }
-exports.GeminiStrategy = GeminiStrategy;