@damador/agentsync 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Krzysztof Radzikowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,121 @@
+# AgentSync 🔄
+
+**AgentSync** is a lightweight, cross-machine synchronization tool designed to persistently migrate and synchronize AI agent session data—including conversation logs, history, and workspace context—across different development machines.
+
+Keep your AI pairing assistants (like Claude Code, Cursor, Aider, Copilot, Gemini, and Codex) perfectly in sync between your workstation, laptop, and remote environments.
+
+---
+
+## Features
+
+- **Multi-Agent Support**: Out-of-the-box support for:
+  - 🤖 **Claude Code**
+  - 🚀 **Cursor**
+  - 💻 **Aider**
+  - 👥 **GitHub Copilot**
+  - ♊ **Gemini**
+  - ⌨️ **Codex CLI**
+- **Git-Backed Vault**: Securely tracks and synchronizes your agent data using a private Git repository as the central storage ("vault").
+- **Seamless Local Persistence**: Exports from local application directories and imports them back smoothly.
+- **Developer-Friendly CLI**: Intuitive commands to keep your workflow synchronized with minimal friction.
+
+---
+
+## Installation
+
+You can run AgentSync directly via `npx` without installing it:
+
+```bash
+npx @damador/agentsync init <your-private-vault-git-repo-url>
+```
+
+Alternatively, you can install it globally to use the `agentsync` command anywhere:
+
+```bash
+npm install -g @damador/agentsync
+```
+
+---
+
+## Usage
+
+AgentSync commands can be run directly using `npx` (or `agentsync` if installed globally):
+
+### 1. Initialize the Vault
+Connect your AgentSync to a private remote Git repository which will act as your cross-machine vault:
+```bash
+npx @damador/agentsync init <your-private-vault-git-repo-url>
+```
+
+### 2. Configure Active Agents
+By default, the first time you run a sync command, an **interactive setup wizard** will detect the agents installed on your machine and ask you to select which ones to sync.
+
+You can also trigger the wizard or configure this manually at any time:
+```bash
+# Run the interactive setup wizard
+npx @damador/agentsync config
+
+# Or manually set specific agents
+npx @damador/agentsync config --agents claude,cursor
+```
+
+*You'll see a prompt like this:*
+```
+Welcome to AgentSync! Let's configure which agents to synchronize.
+? Select the agents you want to sync »
+Instructions:
+    ↑/↓: Highlight option
+    ←/→/[space]: Toggle selection
+    a: Toggle all
+    enter/return: Complete answer
+( )   claude - Not detected locally
+(*)   cursor - Detected locally
+( )   aider - Not detected locally
+(*)   copilot - Detected locally
+( )   gemini - Not detected locally
+( )   codex - Not detected locally
+```
+
+### 3. Export & Push Agent Sessions
+To save your current local sessions and push them to your remote vault:
+```bash
+npx @damador/agentsync push
+```
+
+### 4. Pull & Import Agent Sessions
+On another machine, pull the latest data from the remote vault and import it into your local agent directories:
+```bash
+npx @damador/agentsync pull
+```
+
+### 5. Check Vault Status
+Check the status of your local synchronization vault:
+```bash
+npx @damador/agentsync status
+```
+
+---
+
+## Testing
+
+AgentSync includes a comprehensive test suite powered by **Vitest**. The tests heavily mock filesystem operations (`fs-extra`) and git interactions (`simple-git`) to ensure they run quickly and safely without altering your real local files or Git repositories.
+
+To run the test suite:
+
+```bash
+npm test
+```
+
+---
+
+## How It Works
+
+1. **Vault Management**: AgentSync manages a local vault directory that holds exported configuration, database files, and JSONL log files from supported agents.
+2. **Push/Pull Engine**: Uses a Git-backed engine to track file changes and handle version synchronization (commit, pull, push) securely and privately.
+3. **Provider System**: Each agent provider defines how to locate, export, and import its session files safely.
+
+---
+
+## License
+
+MIT License.

package/dist/gitSync.d.ts

@@ -0,0 +1,8 @@
+export declare class GitSyncEngine {
+    private git;
+    private repoDir;
+    constructor(repoDir: string);
+    init(remoteUrl: string): Promise<void>;
+    pull(): Promise<void>;
+    push(message?: string): Promise<void>;
+}

package/dist/gitSync.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitSyncEngine = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const fs = __importStar(require("fs-extra"));
+class GitSyncEngine {
+    git;
+    repoDir;
+    constructor(repoDir) {
+        this.repoDir = repoDir;
+        this.git = (0, simple_git_1.default)(this.repoDir);
+    }
+    async init(remoteUrl) {
+        await fs.ensureDir(this.repoDir);
+        const isRepo = await this.git.checkIsRepo();
+        if (!isRepo) {
+            await this.git.init();
+            await this.git.addRemote('origin', remoteUrl);
+        }
+    }
+    async pull() {
+        // Stash any local changes before pulling to avoid merge conflicts
+        const status = await this.git.status();
+        let stashed = false;
+        if (status.files.length > 0) {
+            await this.git.stash();
+            stashed = true;
+        }
+        try {
+            await this.git.pull('origin', 'main', { '--rebase': 'true' });
+        }
+        catch (error) {
+            // If pull fails (e.g., no remote branch yet), just ignore
+            console.log('Notice: Could not pull from remote (might be empty or unreachable).');
+        }
+        if (stashed) {
+            try {
+                await this.git.stash(['pop']);
+            }
+            catch (error) {
+                console.warn('Warning: Could not pop stash after pull. You may need to resolve conflicts manually.');
+            }
+        }
+    }
+    async push(message = 'Sync agent data') {
+        await this.git.add('./*');
+        const status = await this.git.status();
+        // Ensure the branch is renamed to main (in case it defaulted to master)
+        try {
+            await this.git.branch(['-M', 'main']);
+        }
+        catch (e) {
+            // Ignore if it fails (e.g., if there are no commits yet)
+        }
+        if (status.staged.length > 0 || status.created.length > 0 || status.modified.length > 0 || status.deleted.length > 0) {
+            await this.git.commit(message);
+        }
+        else {
+            console.log('No new changes to commit.');
+        }
+        // Always attempt to push (there might be unpushed commits even if working tree is clean)
+        await this.git.push('origin', 'main', { '--set-upstream': null });
+    }
+}
+exports.GitSyncEngine = GitSyncEngine;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,201 @@
+#!/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 prompts_1 = __importDefault(require("prompts"));
+const vault_1 = require("./vault");
+const gitSync_1 = require("./gitSync");
+const claudeCode_1 = require("./providers/claudeCode");
+const cursor_1 = require("./providers/cursor");
+const aider_1 = require("./providers/aider");
+const copilot_1 = require("./providers/copilot");
+const gemini_1 = require("./providers/gemini");
+const codex_1 = require("./providers/codex");
+const program = new commander_1.Command();
+const vaultManager = new vault_1.VaultManager();
+const providers = [
+    new claudeCode_1.ClaudeCodeProvider(),
+    new cursor_1.CursorProvider(),
+    new aider_1.AiderProvider(),
+    new copilot_1.CopilotProvider(),
+    new gemini_1.GeminiProvider(),
+    new codex_1.CodexProvider()
+];
+async function runSetupWizard() {
+    console.log('\nWelcome to AgentSync! Let\'s configure which agents to synchronize.');
+    // Detect installed agents
+    const choices = [];
+    for (const provider of providers) {
+        const installed = await provider.isInstalled();
+        choices.push({
+            title: provider.name,
+            value: provider.name,
+            selected: installed,
+            description: installed ? 'Detected locally' : 'Not detected locally'
+        });
+    }
+    const response = await (0, prompts_1.default)({
+        type: 'multiselect',
+        name: 'agents',
+        message: 'Select the agents you want to sync',
+        choices,
+        min: 1
+    });
+    if (response.agents) {
+        const config = await vaultManager.getConfig();
+        config.agents = response.agents;
+        await vaultManager.saveConfig(config);
+        console.log(`\nConfiguration saved. Active agents: ${config.agents.join(', ')}\n`);
+    }
+    else {
+        console.log('\nSetup cancelled. No agents configured.\n');
+        process.exit(1);
+    }
+}
+program
+    .name('agentsync')
+    .description('Synchronize AI agent sessions across machines')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize the AgentSync vault and connect to a remote Git repository')
+    .argument('<repo>', 'Git repository URL')
+    .action(async (repo) => {
+    try {
+        console.log('Initializing AgentSync vault...');
+        await vaultManager.initVault();
+        const gitSync = new gitSync_1.GitSyncEngine(vaultManager.getVaultDir());
+        await gitSync.init(repo);
+        console.log('Successfully initialized AgentSync vault connected to', repo);
+    }
+    catch (error) {
+        console.error('Failed to initialize:', error);
+    }
+});
+program
+    .command('config')
+    .description('Manage AgentSync configuration')
+    .option('--agents <agents>', 'Comma-separated list of agents to sync (e.g., claude,cursor)')
+    .action(async (options) => {
+    try {
+        const config = await vaultManager.getConfig();
+        if (options.agents) {
+            const agents = options.agents.split(',').map((a) => a.trim().toLowerCase());
+            config.agents = agents;
+            await vaultManager.saveConfig(config);
+            console.log(`Config updated. Active agents: ${agents.join(', ')}`);
+        }
+        else {
+            // Run wizard if no options are passed
+            await runSetupWizard();
+        }
+    }
+    catch (e) {
+        console.error('Failed to update config:', e);
+    }
+});
+program
+    .command('push')
+    .description('Export local agent data and push to the remote vault')
+    .action(async () => {
+    try {
+        if (await vaultManager.isFirstRun()) {
+            await runSetupWizard();
+        }
+        console.log('Preparing to push data...');
+        await vaultManager.initVault();
+        const vaultDir = vaultManager.getVaultDir();
+        let activeProviders = providers;
+        const config = await vaultManager.getConfig();
+        if (config.agents && config.agents.length > 0) {
+            const configuredAgents = config.agents;
+            activeProviders = providers.filter(p => configuredAgents.includes(p.name.toLowerCase()));
+            if (activeProviders.length === 0) {
+                console.log('No matching agents found. Check your config.');
+                return;
+            }
+        }
+        // Export from all selected providers
+        for (const provider of activeProviders) {
+            try {
+                await provider.exportToVault(vaultDir);
+            }
+            catch (e) {
+                console.error(`Error exporting ${provider.name}:`, e);
+            }
+        }
+        const gitSync = new gitSync_1.GitSyncEngine(vaultDir);
+        await gitSync.push('Auto-sync agent data from ' + new Date().toISOString());
+        console.log('Push complete.');
+    }
+    catch (error) {
+        console.error('Failed to push:', error);
+    }
+});
+program
+    .command('pull')
+    .description('Pull data from the remote vault and import into local agents')
+    .action(async () => {
+    try {
+        if (await vaultManager.isFirstRun()) {
+            await runSetupWizard();
+        }
+        console.log('Preparing to pull data...');
+        await vaultManager.initVault();
+        const vaultDir = vaultManager.getVaultDir();
+        const gitSync = new gitSync_1.GitSyncEngine(vaultDir);
+        await gitSync.pull();
+        let activeProviders = providers;
+        const config = await vaultManager.getConfig();
+        if (config.agents && config.agents.length > 0) {
+            const configuredAgents = config.agents;
+            activeProviders = providers.filter(p => configuredAgents.includes(p.name.toLowerCase()));
+            if (activeProviders.length === 0) {
+                console.log('No matching agents found. Check your config.');
+                return;
+            }
+        }
+        // Import into all selected providers
+        for (const provider of activeProviders) {
+            try {
+                await provider.importFromVault(vaultDir);
+            }
+            catch (e) {
+                console.error(`Error importing ${provider.name}:`, e);
+            }
+        }
+        console.log('Pull complete.');
+    }
+    catch (error) {
+        console.error('Failed to pull:', error);
+    }
+});
+program
+    .command('status')
+    .description('Check the status of the local vault')
+    .action(async () => {
+    try {
+        const vaultDir = vaultManager.getVaultDir();
+        console.log(`Vault directory: ${vaultDir}`);
+        const gitSync = new gitSync_1.GitSyncEngine(vaultDir);
+        // Let simpleGit handle it (dirty hack but works for logging)
+        const git = require('simple-git')(vaultDir);
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            console.log('Vault is not a git repository. Run `agentsync init <repo>` first.');
+            return;
+        }
+        const status = await git.status();
+        console.log(`Current branch: ${status.current}`);
+        console.log(`Tracking: ${status.tracking}`);
+        console.log(`Modified files: ${status.modified.length}`);
+        console.log(`Untracked files: ${status.not_added.length}`);
+    }
+    catch (error) {
+        console.error('Failed to check status:', error);
+    }
+});
+program.parse();

package/dist/provider.d.ts

@@ -0,0 +1,21 @@
+export interface SyncProvider {
+    /**
+     * The name of the AI agent (e.g., 'claude', 'cursor', 'aider')
+     */
+    name: string;
+    /**
+     * Extracts data from the agent's local directories and copies it into the vault.
+     * @param vaultDir The base directory of the vault.
+     */
+    exportToVault(vaultDir: string): Promise<void>;
+    /**
+     * Restores data from the vault back into the agent's local directories.
+     * @param vaultDir The base directory of the vault.
+     */
+    importFromVault(vaultDir: string): Promise<void>;
+    /**
+     * Checks whether the agent is installed locally on this machine.
+     * Used to auto-detect agents during first run setup.
+     */
+    isInstalled(): Promise<boolean>;
+}

package/dist/provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/providers/aider.d.ts

@@ -0,0 +1,9 @@
+import { SyncProvider } from '../provider';
+export declare class AiderProvider implements SyncProvider {
+    name: string;
+    private getProjectHash;
+    private getAiderFiles;
+    isInstalled(): Promise<boolean>;
+    exportToVault(vaultDir: string): Promise<void>;
+    importFromVault(vaultDir: string): Promise<void>;
+}

package/dist/providers/aider.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiderProvider = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const crypto = __importStar(require("crypto"));
+class AiderProvider {
+    name = 'aider';
+    getProjectHash(dir) {
+        return crypto.createHash('md5').update(dir).digest('hex');
+    }
+    getAiderFiles() {
+        const cwd = process.cwd();
+        return [
+            path.join(cwd, '.aider.chat.history.md'),
+            path.join(cwd, '.aider.input.history'),
+            path.join(cwd, '.aider.tags.cache.v3')
+        ];
+    }
+    async isInstalled() {
+        const files = this.getAiderFiles();
+        for (const f of files) {
+            if (await fs.pathExists(f))
+                return true;
+        }
+        return false;
+    }
+    async exportToVault(vaultDir) {
+        const cwd = process.cwd();
+        const hash = this.getProjectHash(cwd);
+        const vaultAiderDir = path.join(vaultDir, this.name, hash);
+        const aiderFiles = this.getAiderFiles();
+        let exported = false;
+        for (const file of aiderFiles) {
+            if (await fs.pathExists(file)) {
+                if (!exported) {
+                    await fs.ensureDir(vaultAiderDir);
+                    exported = true;
+                }
+                const fileName = path.basename(file);
+                const vaultFile = path.join(vaultAiderDir, fileName);
+                await fs.copy(file, vaultFile, { overwrite: true });
+                console.log(`Exported Aider file: ${fileName}`);
+            }
+        }
+    }
+    async importFromVault(vaultDir) {
+        const cwd = process.cwd();
+        const hash = this.getProjectHash(cwd);
+        const vaultAiderDir = path.join(vaultDir, this.name, hash);
+        if (await fs.pathExists(vaultAiderDir)) {
+            const files = await fs.readdir(vaultAiderDir);
+            for (const file of files) {
+                const vaultFile = path.join(vaultAiderDir, file);
+                const localFile = path.join(cwd, file);
+                await fs.copy(vaultFile, localFile, { overwrite: true });
+                console.log(`Imported Aider file: ${file}`);
+            }
+        }
+        else {
+            console.log(`No Aider data found in vault for current project.`);
+        }
+    }
+}
+exports.AiderProvider = AiderProvider;

package/dist/providers/claudeCode.d.ts

@@ -0,0 +1,8 @@
+import { SyncProvider } from '../provider';
+export declare class ClaudeCodeProvider implements SyncProvider {
+    name: string;
+    private getLocalClaudeDir;
+    isInstalled(): Promise<boolean>;
+    exportToVault(vaultDir: string): Promise<void>;
+    importFromVault(vaultDir: string): Promise<void>;
+}

package/dist/providers/claudeCode.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeProvider = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class ClaudeCodeProvider {
+    name = 'claude';
+    getLocalClaudeDir() {
+        const homeDir = os.homedir();
+        // Claude Code uses ~/.claude or %USERPROFILE%\.claude
+        return path.join(homeDir, '.claude');
+    }
+    async isInstalled() {
+        return fs.pathExists(this.getLocalClaudeDir());
+    }
+    async exportToVault(vaultDir) {
+        const localDir = this.getLocalClaudeDir();
+        const vaultClaudeDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(localDir)) {
+            console.log(`Exporting ${this.name} data...`);
+            await fs.ensureDir(vaultClaudeDir);
+            // Copy the entire .claude directory to the vault, excluding potentially huge caches if needed
+            // but for now, copy everything.
+            await fs.copy(localDir, vaultClaudeDir, {
+                overwrite: true,
+                errorOnExist: false,
+                filter: (src) => {
+                    // You might want to exclude things here, like active sockets or massive log files if any exist
+                    return true;
+                }
+            });
+            console.log(`Successfully exported ${this.name} data.`);
+        }
+        else {
+            console.log(`${this.name} local data not found at ${localDir}, skipping export.`);
+        }
+    }
+    async importFromVault(vaultDir) {
+        const localDir = this.getLocalClaudeDir();
+        const vaultClaudeDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(vaultClaudeDir)) {
+            console.log(`Importing ${this.name} data...`);
+            await fs.ensureDir(localDir);
+            // Copy from vault back to local
+            await fs.copy(vaultClaudeDir, localDir, {
+                overwrite: true,
+                errorOnExist: false
+            });
+            console.log(`Successfully imported ${this.name} data.`);
+        }
+        else {
+            console.log(`${this.name} data not found in vault, skipping import.`);
+        }
+    }
+}
+exports.ClaudeCodeProvider = ClaudeCodeProvider;

package/dist/providers/codex.d.ts

@@ -0,0 +1,8 @@
+import { SyncProvider } from '../provider';
+export declare class CodexProvider implements SyncProvider {
+    name: string;
+    private getLocalCodexDir;
+    isInstalled(): Promise<boolean>;
+    exportToVault(vaultDir: string): Promise<void>;
+    importFromVault(vaultDir: string): Promise<void>;
+}

package/dist/providers/codex.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexProvider = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class CodexProvider {
+    name = 'codex';
+    getLocalCodexDir() {
+        const homeDir = os.homedir();
+        // Codex CLI uses ~/.codex
+        return path.join(homeDir, '.codex');
+    }
+    async isInstalled() {
+        return fs.pathExists(this.getLocalCodexDir());
+    }
+    async exportToVault(vaultDir) {
+        const localDir = this.getLocalCodexDir();
+        const vaultCodexDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(localDir)) {
+            console.log(`Exporting ${this.name} data...`);
+            await fs.ensureDir(vaultCodexDir);
+            await fs.copy(localDir, vaultCodexDir, {
+                overwrite: true,
+                errorOnExist: false
+            });
+            console.log(`Successfully exported ${this.name} data.`);
+        }
+        else {
+            console.log(`${this.name} local data not found at ${localDir}, skipping export.`);
+        }
+    }
+    async importFromVault(vaultDir) {
+        const localDir = this.getLocalCodexDir();
+        const vaultCodexDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(vaultCodexDir)) {
+            console.log(`Importing ${this.name} data...`);
+            await fs.ensureDir(localDir);
+            await fs.copy(vaultCodexDir, localDir, {
+                overwrite: true,
+                errorOnExist: false
+            });
+            console.log(`Successfully imported ${this.name} data.`);
+        }
+        else {
+            console.log(`${this.name} data not found in vault, skipping import.`);
+        }
+    }
+}
+exports.CodexProvider = CodexProvider;

package/dist/providers/copilot.d.ts

@@ -0,0 +1,8 @@
+import { SyncProvider } from '../provider';
+export declare class CopilotProvider implements SyncProvider {
+    name: string;
+    private getWorkspaceStorageDir;
+    isInstalled(): Promise<boolean>;
+    exportToVault(vaultDir: string): Promise<void>;
+    importFromVault(vaultDir: string): Promise<void>;
+}

package/dist/providers/copilot.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotProvider = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class CopilotProvider {
+    name = 'copilot';
+    getWorkspaceStorageDir() {
+        const platform = os.platform();
+        const homeDir = os.homedir();
+        if (platform === 'win32') {
+            const appData = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+            return path.join(appData, 'Code', 'User', 'workspaceStorage');
+        }
+        else if (platform === 'darwin') {
+            return path.join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage');
+        }
+        else {
+            return path.join(homeDir, '.config', 'Code', 'User', 'workspaceStorage');
+        }
+    }
+    async isInstalled() {
+        return fs.pathExists(this.getWorkspaceStorageDir());
+    }
+    async exportToVault(vaultDir) {
+        const storageDir = this.getWorkspaceStorageDir();
+        const vaultCopilotDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(storageDir)) {
+            const workspaces = await fs.readdir(storageDir);
+            let foundCopilotData = false;
+            for (const ws of workspaces) {
+                const wsDir = path.join(storageDir, ws);
+                const stat = await fs.stat(wsDir);
+                if (stat.isDirectory()) {
+                    // Copilot chat is typically stored in GitHub.copilot-chat or similar within the workspace hash
+                    const copilotChatDir = path.join(wsDir, 'GitHub.copilot-chat');
+                    if (await fs.pathExists(copilotChatDir)) {
+                        if (!foundCopilotData) {
+                            await fs.ensureDir(vaultCopilotDir);
+                            foundCopilotData = true;
+                        }
+                        const vaultWsDir = path.join(vaultCopilotDir, ws, 'GitHub.copilot-chat');
+                        await fs.copy(copilotChatDir, vaultWsDir, { overwrite: true });
+                        console.log(`Exported Copilot data for workspace ${ws}`);
+                    }
+                }
+            }
+            if (!foundCopilotData) {
+                console.log(`No Copilot data found in workspaceStorage.`);
+            }
+        }
+        else {
+            console.log(`VS Code workspaceStorage not found at ${storageDir}`);
+        }
+    }
+    async importFromVault(vaultDir) {
+        const storageDir = this.getWorkspaceStorageDir();
+        const vaultCopilotDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(vaultCopilotDir)) {
+            const workspaces = await fs.readdir(vaultCopilotDir);
+            for (const ws of workspaces) {
+                const vaultWsCopilotDir = path.join(vaultCopilotDir, ws, 'GitHub.copilot-chat');
+                const localWsCopilotDir = path.join(storageDir, ws, 'GitHub.copilot-chat');
+                if (await fs.pathExists(vaultWsCopilotDir)) {
+                    await fs.ensureDir(path.join(storageDir, ws));
+                    await fs.copy(vaultWsCopilotDir, localWsCopilotDir, { overwrite: true });
+                    console.log(`Imported Copilot data for workspace ${ws}`);
+                }
+            }
+        }
+        else {
+            console.log(`${this.name} data not found in vault, skipping import.`);
+        }
+    }
+}
+exports.CopilotProvider = CopilotProvider;

package/dist/providers/cursor.d.ts

@@ -0,0 +1,9 @@
+import { SyncProvider } from '../provider';
+export declare class CursorProvider implements SyncProvider {
+    name: string;
+    private getLocalCursorUserDir;
+    private getCursorPaths;
+    isInstalled(): Promise<boolean>;
+    exportToVault(vaultDir: string): Promise<void>;
+    importFromVault(vaultDir: string): Promise<void>;
+}

package/dist/providers/cursor.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorProvider = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class CursorProvider {
+    name = 'cursor';
+    getLocalCursorUserDir() {
+        const platform = os.platform();
+        const homeDir = os.homedir();
+        if (platform === 'win32') {
+            const appData = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+            return path.join(appData, 'Cursor', 'User');
+        }
+        else if (platform === 'darwin') {
+            return path.join(homeDir, 'Library', 'Application Support', 'Cursor', 'User');
+        }
+        else {
+            return path.join(homeDir, '.config', 'Cursor', 'User');
+        }
+    }
+    getCursorPaths() {
+        const baseDir = this.getLocalCursorUserDir();
+        return [
+            path.join(baseDir, 'globalStorage', 'state.vscdb'), // The SQLite database
+            path.join(baseDir, 'workspaceStorage'), // Workspace specific settings
+        ];
+    }
+    async isInstalled() {
+        return fs.pathExists(this.getLocalCursorUserDir());
+    }
+    async exportToVault(vaultDir) {
+        const vaultCursorDir = path.join(vaultDir, this.name);
+        await fs.ensureDir(vaultCursorDir);
+        const pathsToSync = this.getCursorPaths();
+        for (const p of pathsToSync) {
+            if (await fs.pathExists(p)) {
+                const relativePath = path.relative(this.getLocalCursorUserDir(), p);
+                const vaultPath = path.join(vaultCursorDir, relativePath);
+                console.log(`Exporting ${this.name} data: ${relativePath}`);
+                await fs.copy(p, vaultPath, { overwrite: true });
+            }
+        }
+    }
+    async importFromVault(vaultDir) {
+        const vaultCursorDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(vaultCursorDir)) {
+            const pathsToSync = this.getCursorPaths();
+            for (const p of pathsToSync) {
+                const relativePath = path.relative(this.getLocalCursorUserDir(), p);
+                const vaultPath = path.join(vaultCursorDir, relativePath);
+                if (await fs.pathExists(vaultPath)) {
+                    console.log(`Importing ${this.name} data: ${relativePath}`);
+                    await fs.copy(vaultPath, p, { overwrite: true });
+                }
+            }
+        }
+        else {
+            console.log(`${this.name} data not found in vault, skipping import.`);
+        }
+    }
+}
+exports.CursorProvider = CursorProvider;

package/dist/providers/gemini.d.ts

@@ -0,0 +1,8 @@
+import { SyncProvider } from '../provider';
+export declare class GeminiProvider implements SyncProvider {
+    name: string;
+    private getLocalGeminiDir;
+    isInstalled(): Promise<boolean>;
+    exportToVault(vaultDir: string): Promise<void>;
+    importFromVault(vaultDir: string): Promise<void>;
+}

package/dist/providers/gemini.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class GeminiProvider {
+    name = 'gemini';
+    getLocalGeminiDir() {
+        const homeDir = os.homedir();
+        return path.join(homeDir, '.gemini', 'tmp');
+    }
+    async isInstalled() {
+        return fs.pathExists(this.getLocalGeminiDir());
+    }
+    async exportToVault(vaultDir) {
+        const localDir = this.getLocalGeminiDir();
+        const vaultGeminiDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(localDir)) {
+            console.log(`Exporting ${this.name} data...`);
+            await fs.ensureDir(vaultGeminiDir);
+            await fs.copy(localDir, vaultGeminiDir, {
+                overwrite: true,
+                errorOnExist: false
+            });
+            console.log(`Successfully exported ${this.name} data.`);
+        }
+        else {
+            console.log(`${this.name} local data not found at ${localDir}, skipping export.`);
+        }
+    }
+    async importFromVault(vaultDir) {
+        const localDir = this.getLocalGeminiDir();
+        const vaultGeminiDir = path.join(vaultDir, this.name);
+        if (await fs.pathExists(vaultGeminiDir)) {
+            console.log(`Importing ${this.name} data...`);
+            await fs.ensureDir(localDir);
+            await fs.copy(vaultGeminiDir, localDir, {
+                overwrite: true,
+                errorOnExist: false
+            });
+            console.log(`Successfully imported ${this.name} data.`);
+        }
+        else {
+            console.log(`${this.name} data not found in vault, skipping import.`);
+        }
+    }
+}
+exports.GeminiProvider = GeminiProvider;

package/dist/vault.d.ts

@@ -0,0 +1,17 @@
+export interface AgentSyncConfig {
+    agents?: string[];
+}
+export declare class VaultManager {
+    private baseDir;
+    private vaultDir;
+    private configPath;
+    constructor();
+    getVaultDir(): string;
+    initVault(): Promise<void>;
+    getConfig(): Promise<AgentSyncConfig>;
+    saveConfig(config: AgentSyncConfig): Promise<void>;
+    isFirstRun(): Promise<boolean>;
+    cleanVault(): Promise<void>;
+    getAgentVaultDir(agentName: string): string;
+    ensureAgentVaultDir(agentName: string): Promise<void>;
+}

package/dist/vault.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultManager = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class VaultManager {
+    baseDir;
+    vaultDir;
+    configPath;
+    constructor() {
+        this.baseDir = path.join(os.homedir(), '.agentsync');
+        this.vaultDir = path.join(this.baseDir, 'vault');
+        this.configPath = path.join(this.baseDir, 'config.json');
+    }
+    getVaultDir() {
+        return this.vaultDir;
+    }
+    async initVault() {
+        await fs.ensureDir(this.vaultDir);
+    }
+    async getConfig() {
+        if (await fs.pathExists(this.configPath)) {
+            return fs.readJson(this.configPath);
+        }
+        return {};
+    }
+    async saveConfig(config) {
+        await fs.ensureDir(this.baseDir);
+        await fs.writeJson(this.configPath, config, { spaces: 2 });
+    }
+    async isFirstRun() {
+        const config = await this.getConfig();
+        return config.agents === undefined;
+    }
+    async cleanVault() {
+        // Keep the .git folder if it exists, clear everything else
+        const files = await fs.readdir(this.vaultDir);
+        for (const file of files) {
+            if (file !== '.git') {
+                await fs.remove(path.join(this.vaultDir, file));
+            }
+        }
+    }
+    getAgentVaultDir(agentName) {
+        return path.join(this.vaultDir, agentName);
+    }
+    async ensureAgentVaultDir(agentName) {
+        await fs.ensureDir(this.getAgentVaultDir(agentName));
+    }
+}
+exports.VaultManager = VaultManager;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@damador/agentsync",
+  "version": "1.0.1",
+  "description": "Synchronization tool for AI Agent conversations.",
+  "main": "dist/index.js",
+  "bin": {
+    "agentsync": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/index.ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/damadorPL/agentsync.git"
+  },
+  "keywords": [
+    "agentsync",
+    "cli",
+    "sync",
+    "ai",
+    "agent"
+  ],
+  "author": "Krzysztof Radzikowski",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.5",
+    "prompts": "^2.4.2",
+    "simple-git": "^3.36.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.8.0",
+    "@types/prompts": "^2.4.9",
+    "@vitest/coverage-v8": "^4.1.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
+  }
+}