memax-cli 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/commands/sync.js

@@ -1,8 +1,11 @@
 import chalk from "chalk";
-import { readFileSync, readdirSync, statSync, watch, existsSync, } from "node:fs";
-import { join, relative, extname, resolve, basename } from "node:path";
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, watch, existsSync, } from "node:fs";
+import { join, relative, extname, resolve, dirname } from "node:path";
 import { homedir } from "node:os";
-import { apiPost } from "../lib/api.js";
+import { getClient } from "../lib/client.js";
+import { getProjectScope, resolveClaudeProjectFolder, normalizeFilePath, } from "../lib/project-context.js";
+import { confirm, ask, confirmDefault } from "../lib/prompt.js";
 const DEFAULT_IGNORE = new Set([
     "node_modules",
     ".git",
@@ -37,14 +40,136 @@ const SUPPORTED_EXTENSIONS = new Set([
     ".proto",
     ".dockerfile",
 ]);
-export async function syncAgentMemoryCommand() {
-    await syncAgentMemory();
+export async function syncAgentMemoryCommand(options = {}) {
+    await syncAgentMemory(options);
 }
-export async function syncCommand(directory, options) {
-    if (options.agentMemory || directory === "agents") {
-        await syncAgentMemory();
+export async function listAgentConfigsCommand() {
+    let configs;
+    try {
+        const result = await getClient().configs.list();
+        configs = result.configs;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch configs: ${err.message}\n`));
+        return;
+    }
+    if (!configs || configs.length === 0) {
+        console.log(chalk.yellow("  No synced configs. Run: memax agent-configs sync\n"));
         return;
     }
+    // Group by agent
+    const byAgent = new Map();
+    for (const c of configs) {
+        const list = byAgent.get(c.agent) ?? [];
+        list.push({
+            id: c.id,
+            filePath: c.file_path,
+            scope: c.scope,
+            updatedAt: c.updated_at,
+        });
+        byAgent.set(c.agent, list);
+    }
+    console.log();
+    for (const [agent, files] of byAgent) {
+        console.log(`  ${chalk.cyan(agent)}`);
+        for (const f of files) {
+            const scopeTag = f.scope === "global"
+                ? chalk.dim("global")
+                : chalk.dim(f.scope.replace("project:", ""));
+            const age = formatAge(f.updatedAt);
+            console.log(`    ${f.filePath}  ${scopeTag}  ${chalk.dim(age)}  ${chalk.dim(f.id.slice(0, 8))}`);
+        }
+        console.log();
+    }
+    console.log(chalk.gray(`  ${configs.length} config${configs.length > 1 ? "s" : ""} synced to cloud.\n`));
+}
+export async function deleteAgentConfigsCommand() {
+    let configs;
+    try {
+        const result = await getClient().configs.list();
+        configs = result.configs;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Failed to fetch configs: ${err.message}\n`));
+        return;
+    }
+    if (!configs || configs.length === 0) {
+        console.log(chalk.yellow("  No synced configs to delete.\n"));
+        return;
+    }
+    // Display numbered list grouped by agent
+    const items = [];
+    let currentAgent = "";
+    for (const c of configs) {
+        if (c.agent !== currentAgent) {
+            if (currentAgent)
+                console.log();
+            console.log(`  ${chalk.cyan(c.agent)}`);
+            currentAgent = c.agent;
+        }
+        items.push({
+            id: c.id,
+            agent: c.agent,
+            filePath: c.file_path,
+            scope: c.scope,
+        });
+        const idx = chalk.dim(`${items.length}.`);
+        const scopeTag = c.scope === "global"
+            ? chalk.dim("global")
+            : chalk.dim(c.scope.replace("project:", ""));
+        console.log(`    ${idx} ${c.file_path}  ${scopeTag}`);
+    }
+    console.log();
+    const answer = await ask("  Select configs to delete (comma-separated numbers, or 'q' to quit): ");
+    if (!answer || answer.trim().toLowerCase() === "q") {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    const indices = answer
+        .split(",")
+        .map((s) => parseInt(s.trim(), 10))
+        .filter((n) => !isNaN(n) && n >= 1 && n <= items.length);
+    if (indices.length === 0) {
+        console.log(chalk.gray("  No valid selections.\n"));
+        return;
+    }
+    // Confirm
+    console.log();
+    for (const i of indices) {
+        const item = items[i - 1];
+        console.log(chalk.yellow(`    ${item.agent}/${item.filePath}`));
+    }
+    const ok = await confirm(`\n  Delete ${indices.length} config${indices.length > 1 ? "s" : ""}? (y/N) `);
+    if (!ok) {
+        console.log(chalk.gray("  Cancelled.\n"));
+        return;
+    }
+    let deleted = 0;
+    for (const i of indices) {
+        const item = items[i - 1];
+        try {
+            await getClient().configs.delete(item.id);
+            console.log(chalk.green(`    \u2713 ${item.agent}/${item.filePath}`), chalk.gray("deleted"));
+            deleted++;
+        }
+        catch (err) {
+            console.log(chalk.red(`    \u2717 ${item.agent}/${item.filePath}`), chalk.gray(err.message));
+        }
+    }
+    console.log(chalk.gray(`\n  ${deleted} config${deleted > 1 ? "s" : ""} deleted.\n`));
+}
+function formatAge(dateStr) {
+    const ms = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+export async function syncCommand(directory, options) {
     const dir = directory ?? ".";
     const customIgnore = options.ignore
         ? new Set(options.ignore.split(",").map((s) => s.trim()))
@@ -57,6 +182,15 @@ export async function syncCommand(directory, options) {
         return;
     }
     console.log(chalk.gray(`Found ${files.length} files to sync`));
+    // Confirm if many files (>10) unless -y is passed
+    if (files.length > 10 && !options.yes) {
+        console.log(chalk.yellow(`\n  This will push ${files.length} files. Continue? (y/N) `));
+        const confirmed = await confirm("  ");
+        if (!confirmed) {
+            console.log(chalk.gray("  Cancelled.\n"));
+            return;
+        }
+    }
     console.log();
     let pushed = 0;
     let errors = 0;
@@ -108,15 +242,14 @@ async function pushFile(file, options) {
             : ext === ".json" || ext === ".yaml" || ext === ".yml"
                 ? "structured"
                 : "code";
-        const note = await apiPost("/v1/notes", {
-            content,
+        const memory = await getClient().push(content, {
             title: relPath,
             category: options.category ?? guessCategory(relPath),
             source: "sync",
-            source_path: relPath,
-            content_type: contentType,
+            sourcePath: relPath,
+            contentType,
         });
-        console.log(chalk.green("  +"), relPath, chalk.gray(`[${note.category}]`));
+        console.log(chalk.green("  +"), relPath, chalk.gray(`[${memory.category}]`));
         return "pushed";
     }
     catch (err) {
@@ -179,143 +312,517 @@ function guessCategory(path) {
         return "reference/config";
     return "daily/note";
 }
-function discoverAgentMemoryFiles() {
+function discoverAgentConfigs() {
     const home = homedir();
     const cwd = process.cwd();
+    const projectScope = getProjectScope(cwd);
     const locations = [];
-    // Claude Code global memory
-    const claudeMemory = join(home, ".claude", "MEMORY.md");
-    locations.push({ label: "~/.claude/MEMORY.md", path: claudeMemory });
-    // Claude Code per-project memories: ~/.claude/projects/*/memory/*.md
+    const add = (agent, label, path, filePath, scope = "global") => locations.push({
+        agent,
+        label,
+        path,
+        filePath: normalizeFilePath(filePath),
+        scope,
+    });
+    // Claude Code — global
+    add("claude-code", "~/.claude/CLAUDE.md", join(home, ".claude", "CLAUDE.md"), "CLAUDE.md");
+    add("claude-code", "~/.claude/MEMORY.md", join(home, ".claude", "MEMORY.md"), "MEMORY.md");
+    // Claude Code — per-project memories: ~/.claude/projects/*/memory/*.md
+    // The folder name is the absolute project path with "/" replaced by "-"
+    // (e.g., "-workspaces-memax"). We resolve it to a git repo URL so the
+    // same project's memories match across machines regardless of clone path.
     const claudeProjectsDir = join(home, ".claude", "projects");
     if (existsSync(claudeProjectsDir)) {
         try {
             for (const project of readdirSync(claudeProjectsDir)) {
                 const memoryDir = join(claudeProjectsDir, project, "memory");
-                if (existsSync(memoryDir)) {
-                    try {
-                        for (const file of readdirSync(memoryDir)) {
-                            if (file.endsWith(".md")) {
-                                locations.push({
-                                    label: `~/.claude/projects/${project}/memory/${file}`,
-                                    path: join(memoryDir, file),
-                                });
-                            }
+                if (!existsSync(memoryDir))
+                    continue;
+                // Try to resolve mangled folder → git repo → canonical scope
+                const repoUrl = resolveClaudeProjectFolder(project);
+                const memoryScope = repoUrl ? `project:${repoUrl}` : undefined;
+                try {
+                    for (const file of readdirSync(memoryDir)) {
+                        if (!file.endsWith(".md"))
+                            continue;
+                        if (memoryScope) {
+                            // Canonical: filePath is just "memory/<file>", scope identifies the project
+                            add("claude-code", `~/.claude/projects/${project}/memory/${file}`, join(memoryDir, file), `memory/${file}`, memoryScope);
+                        }
+                        else {
+                            // Fallback: can't resolve project → keep legacy format with folder name
+                            add("claude-code", `~/.claude/projects/${project}/memory/${file}`, join(memoryDir, file), `projects/${project}/memory/${file}`);
                         }
                     }
-                    catch {
-                        // Permission denied or other read error — skip
-                    }
+                }
+                catch {
+                    // Permission denied — skip
                 }
             }
         }
         catch {
-            // Permission denied or other read error — skip
+            // Permission denied — skip
         }
     }
-    // Cursor rules (project-level)
-    locations.push({ label: "./.cursorrules", path: join(cwd, ".cursorrules") });
-    // Cursor scoped rules: .cursor/rules/*.mdc
+    // Claude Code — project-level
+    add("claude-code", "./.claude/CLAUDE.md", join(cwd, ".claude", "CLAUDE.md"), "CLAUDE.md", projectScope);
+    // Cursor (project-level)
+    add("cursor", "./.cursorrules", join(cwd, ".cursorrules"), ".cursorrules", projectScope);
     const cursorRulesDir = join(cwd, ".cursor", "rules");
     if (existsSync(cursorRulesDir)) {
         try {
             for (const file of readdirSync(cursorRulesDir)) {
                 if (file.endsWith(".mdc")) {
-                    locations.push({
-                        label: `./.cursor/rules/${file}`,
-                        path: join(cursorRulesDir, file),
-                    });
+                    add("cursor", `./.cursor/rules/${file}`, join(cursorRulesDir, file), `.cursor/rules/${file}`, projectScope);
                 }
             }
         }
         catch {
-            // Skip on error
+            /* skip */
         }
     }
-    // Codex instructions
-    locations.push({
-        label: "./.codex/instructions.md",
-        path: join(cwd, ".codex", "instructions.md"),
-    });
-    // Generic agent config files in current directory
-    locations.push({ label: "./AGENTS.md", path: join(cwd, "AGENTS.md") });
-    locations.push({ label: "./CLAUDE.md", path: join(cwd, "CLAUDE.md") });
-    return locations;
-}
-function formatFileSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    return `${(bytes / 1024).toFixed(1)} KB`;
-}
-async function syncAgentMemory() {
-    console.log(chalk.blue("Scanning for agent memory files..."));
-    console.log();
-    const locations = discoverAgentMemoryFiles();
-    const found = [];
-    const notFound = [];
-    for (const loc of locations) {
-        if (existsSync(loc.path)) {
-            try {
-                const stat = statSync(loc.path);
-                if (stat.isFile() && stat.size > 0) {
-                    found.push({ label: loc.label, path: loc.path, size: stat.size });
-                }
-                else {
-                    notFound.push(loc.label);
+    // Codex
+    add("codex", "./.codex/instructions.md", join(cwd, ".codex", "instructions.md"), "instructions.md", projectScope);
+    add("codex", "~/.codex/AGENTS.md", join(home, ".codex", "AGENTS.md"), "AGENTS.md");
+    // Gemini CLI
+    add("gemini", "~/.gemini/GEMINI.md", join(home, ".gemini", "GEMINI.md"), "GEMINI.md");
+    add("gemini", "./GEMINI.md", join(cwd, "GEMINI.md"), "GEMINI.md", projectScope);
+    // GitHub Copilot
+    add("copilot", "./.github/copilot-instructions.md", join(cwd, ".github", "copilot-instructions.md"), "copilot-instructions.md", projectScope);
+    // Windsurf
+    add("windsurf", "./.windsurfrules", join(cwd, ".windsurfrules"), ".windsurfrules", projectScope);
+    const windsurfRulesDir = join(cwd, ".windsurf", "rules");
+    if (existsSync(windsurfRulesDir)) {
+        try {
+            for (const file of readdirSync(windsurfRulesDir)) {
+                if (file.endsWith(".md")) {
+                    add("windsurf", `./.windsurf/rules/${file}`, join(windsurfRulesDir, file), `.windsurf/rules/${file}`, projectScope);
                 }
             }
-            catch {
-                notFound.push(loc.label);
-            }
         }
-        else {
-            notFound.push(loc.label);
+        catch {
+            /* skip */
         }
     }
-    if (found.length === 0) {
-        console.log(chalk.yellow("No agent memory files found."));
-        return;
-    }
-    console.log("Found:");
-    for (const f of found) {
-        console.log(chalk.green("  \u2713"), f.label, chalk.gray(`(${formatFileSize(f.size)})`));
+    // OpenClaw
+    const openclawMemoryDir = join(home, ".openclaw", "memory");
+    if (existsSync(openclawMemoryDir)) {
+        try {
+            for (const file of readdirSync(openclawMemoryDir)) {
+                if (file.endsWith(".md") || file.endsWith(".json")) {
+                    add("openclaw", `~/.openclaw/memory/${file}`, join(openclawMemoryDir, file), `memory/${file}`);
+                }
+            }
+        }
+        catch {
+            /* skip */
+        }
     }
-    for (const label of notFound) {
-        console.log(chalk.gray("  \u2717"), chalk.gray(label), chalk.gray("(not found)"));
+    // OpenCode (project-level)
+    const opencodePath = join(cwd, ".opencode");
+    if (existsSync(opencodePath)) {
+        try {
+            for (const file of readdirSync(opencodePath)) {
+                if (file.endsWith(".md")) {
+                    add("opencode", `./.opencode/${file}`, join(opencodePath, file), file, projectScope);
+                }
+            }
+        }
+        catch {
+            /* skip */
+        }
     }
-    console.log();
-    let synced = 0;
-    let unchanged = 0;
-    let errors = 0;
-    for (const f of found) {
+    // Generic project-level agent files
+    add("generic", "./AGENTS.md", join(cwd, "AGENTS.md"), "AGENTS.md", projectScope);
+    add("generic", "./CLAUDE.md", join(cwd, "CLAUDE.md"), "CLAUDE.md", projectScope);
+    return locations;
+}
+async function syncAgentMemory(options = {}) {
+    console.log(chalk.bold("\n  Memax Config Sync\n"));
+    // Discover local config files
+    const locations = discoverAgentConfigs();
+    const localConfigs = [];
+    for (const loc of locations) {
+        if (!existsSync(loc.path))
+            continue;
         try {
-            const content = readFileSync(f.path, "utf-8");
+            const stat = statSync(loc.path);
+            if (!stat.isFile() || stat.size === 0)
+                continue;
+            const content = readFileSync(loc.path, "utf-8");
             if (!content.trim())
                 continue;
-            const title = basename(f.path);
-            await apiPost("/v1/notes", {
+            const hash = createHash("sha256").update(content).digest("hex");
+            localConfigs.push({
+                loc,
                 content,
-                title,
-                source: "sync",
-                source_path: f.path,
-                content_type: "markdown",
-                category: "",
+                hash,
+                updatedAt: stat.mtime.toISOString(),
             });
-            synced++;
         }
-        catch (err) {
-            const msg = err.message;
-            if (msg.includes("unchanged") ||
-                msg.includes("duplicate") ||
-                msg.includes("exists")) {
-                unchanged++;
+        catch {
+            // Skip unreadable files
+        }
+    }
+    const isBootstrap = localConfigs.length === 0;
+    if (isBootstrap) {
+        console.log(chalk.gray("  No local agent configs found. Checking cloud for backups...\n"));
+    }
+    else {
+        console.log(chalk.gray(`  Found ${localConfigs.length} local config${localConfigs.length > 1 ? "s" : ""}. Syncing with cloud...\n`));
+    }
+    // Build manifest — may be empty on a new device (that's fine, we'll pull from cloud)
+    const manifest = localConfigs.map((c) => ({
+        agent: c.loc.agent,
+        file_path: c.loc.filePath,
+        scope: c.loc.scope,
+        content_hash: c.hash,
+        updated_at: c.updatedAt,
+    }));
+    let actions;
+    try {
+        const plan = await getClient().configs.sync(manifest);
+        actions = plan.actions;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Sync failed: ${err.message}\n`));
+        return;
+    }
+    // Force modes override the plan
+    if (options.push) {
+        actions = actions.map((a) => a.action === "pull" || a.action === "conflict"
+            ? { ...a, action: "push" }
+            : a);
+    }
+    else if (options.pull) {
+        actions = actions.map((a) => a.action === "push" || a.action === "conflict"
+            ? { ...a, action: "pull" }
+            : a);
+    }
+    // Filter out project-scoped cloud-only configs that don't belong to the
+    // current project. Without this, running `memax sync agents` from ~/
+    // would dump project configs (like .cursorrules from repo X) into the
+    // home directory.
+    const currentProjectScope = getProjectScope();
+    actions = actions.filter((a) => {
+        if (!a.scope.startsWith("project:"))
+            return true; // global → always sync
+        if (a.scope === "project")
+            return true; // legacy → keep for compat
+        // Project-scoped: only sync if it matches the current project
+        if (a.scope === currentProjectScope)
+            return true;
+        // Cloud-only configs for other projects → skip silently
+        if (a.action === "pull" && a.reason === "cloud_only")
+            return false;
+        // Conflict/push for configs we have locally → keep (user is in the project)
+        return true;
+    });
+    // Index local configs by (agent, file_path, scope) for quick lookup
+    const localByKey = new Map();
+    for (const c of localConfigs) {
+        localByKey.set(`${c.loc.agent}|${c.loc.filePath}|${c.loc.scope}`, c);
+    }
+    // Index locations by (agent, file_path, scope) for pull path resolution
+    const locByKey = new Map();
+    for (const loc of locations) {
+        locByKey.set(`${loc.agent}|${loc.filePath}|${loc.scope}`, loc);
+    }
+    // Resolve a local write path for any config — even ones not discovered locally.
+    // This enables pulling configs to a brand-new device where agent dirs don't exist yet.
+    const resolveWritePath = (agent, filePath, scope) => {
+        // First check if we have a known location from local discovery
+        const loc = locByKey.get(`${agent}|${filePath}|${scope}`);
+        if (loc)
+            return loc.path;
+        const home = homedir();
+        // Global configs: reconstruct from agent dir + filePath
+        if (scope === "global") {
+            const agentDirs = {
+                "claude-code": join(home, ".claude"),
+                cursor: join(home, ".cursor"),
+                codex: join(home, ".codex"),
+                gemini: join(home, ".gemini"),
+                copilot: join(home, ".copilot"),
+                windsurf: join(home, ".windsurf"),
+                openclaw: join(home, ".openclaw"),
+                opencode: join(home, ".opencode"),
+            };
+            const dir = agentDirs[agent];
+            if (dir)
+                return join(dir, filePath);
+        }
+        // Project-scoped configs — ONLY write if we're in the matching project.
+        // This is the safety net: never write project files to the wrong directory.
+        if (scope.startsWith("project")) {
+            // Verify this scope matches the current project
+            if (scope !== "project" && scope !== currentProjectScope) {
+                return null; // Wrong project — refuse to write
+            }
+            // Claude per-project memories: filePath like "memory/feedback.md"
+            if (agent === "claude-code" && filePath.startsWith("memory/")) {
+                const projectDir = findClaudeProjectDir(scope);
+                if (projectDir)
+                    return join(projectDir, filePath);
+                // Fallback: use mangled cwd path
+                const mangledCwd = process.cwd().replace(/\//g, "-");
+                return join(home, ".claude", "projects", mangledCwd, filePath);
+            }
+            // Regular project configs: write relative to cwd
+            return join(process.cwd(), filePath);
+        }
+        return null;
+    };
+    /**
+     * Find the local ~/.claude/projects/<mangled> directory that corresponds
+     * to a given project scope (e.g., "project:github.com/memaxlabs/memax").
+     */
+    function findClaudeProjectDir(scope) {
+        const home = homedir();
+        const claudeProjectsDir = join(home, ".claude", "projects");
+        if (!existsSync(claudeProjectsDir))
+            return null;
+        try {
+            for (const project of readdirSync(claudeProjectsDir)) {
+                const repoUrl = resolveClaudeProjectFolder(project);
+                if (repoUrl && scope === `project:${repoUrl}`) {
+                    return join(claudeProjectsDir, project);
+                }
+            }
+        }
+        catch {
+            // Permission denied — skip
+        }
+        return null;
+    }
+    // Execute sync plan
+    let pushed = 0;
+    let pulled = 0;
+    let unchangedCount = 0;
+    let skipped = 0;
+    let errors = 0;
+    // Group actions by agent for display
+    const byAgent = new Map();
+    for (const action of actions) {
+        const group = byAgent.get(action.agent) ?? [];
+        group.push(action);
+        byAgent.set(action.agent, group);
+    }
+    for (const [agent, agentActions] of byAgent) {
+        console.log(chalk.white(`  ${formatAgentName(agent)}`));
+        for (const action of agentActions) {
+            const key = `${action.agent}|${action.file_path}|${action.scope}`;
+            if (action.action === "unchanged") {
+                console.log(chalk.gray(`    = ${action.file_path}`), chalk.gray("unchanged"));
+                unchangedCount++;
+                continue;
+            }
+            if (action.action === "push") {
+                const local = localByKey.get(key);
+                if (!local) {
+                    errors++;
+                    continue;
+                }
+                try {
+                    await getClient().configs.upsert({
+                        agent: action.agent,
+                        file_path: action.file_path,
+                        scope: action.scope,
+                        content: local.content,
+                    });
+                    console.log(chalk.green(`    \u2191 ${action.file_path}`), chalk.gray(action.reason === "local_only"
+                        ? "pushing (new)"
+                        : "pushing (local newer)"));
+                    pushed++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
+            }
+            if (action.action === "pull") {
+                if (!action.config_id) {
+                    errors++;
+                    continue;
+                }
+                try {
+                    const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                    if (!writePath) {
+                        console.log(chalk.yellow(`    ? ${action.file_path}`), chalk.gray(action.scope !== "global" &&
+                            action.scope !== currentProjectScope
+                            ? "different project \u2014 skipped"
+                            : "unknown agent \u2014 skipped"));
+                        skipped++;
+                        continue;
+                    }
+                    // For new files (not updates), ask user before writing
+                    const isNewLocally = action.reason === "cloud_only" && !existsSync(writePath);
+                    if (isNewLocally && !options.pull) {
+                        console.log(chalk.cyan(`    New file: ${action.file_path}`));
+                        console.log(chalk.gray(`    → ${writePath}`));
+                        const accept = await confirmDefault(`    Download? [Y/n] `);
+                        if (!accept) {
+                            console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                            skipped++;
+                            continue;
+                        }
+                    }
+                    const config = await getClient().configs.get(action.config_id);
+                    mkdirSync(dirname(writePath), { recursive: true });
+                    writeFileSync(writePath, config.content);
+                    console.log(chalk.cyan(`    \u2193 ${action.file_path}`), chalk.gray(isNewLocally ? "restored" : "pulling (cloud newer)"));
+                    pulled++;
+                }
+                catch (err) {
+                    console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                    errors++;
+                }
+                continue;
             }
-            else {
-                errors++;
-                console.log(chalk.red("  Error syncing"), f.label, chalk.gray(msg));
+            if (action.action === "conflict") {
+                const resolution = await promptConflict(agent, action.file_path);
+                if (resolution === "local") {
+                    const local = localByKey.get(key);
+                    if (local) {
+                        try {
+                            await getClient().configs.upsert({
+                                agent: action.agent,
+                                file_path: action.file_path,
+                                scope: action.scope,
+                                content: local.content,
+                            });
+                            console.log(chalk.green(`    \u2191 ${action.file_path}`), chalk.gray("kept local"));
+                            pushed++;
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                            errors++;
+                        }
+                    }
+                }
+                else if (resolution === "cloud" && action.config_id) {
+                    try {
+                        const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                        if (writePath) {
+                            const config = await getClient().configs.get(action.config_id);
+                            mkdirSync(dirname(writePath), { recursive: true });
+                            writeFileSync(writePath, config.content);
+                            console.log(chalk.cyan(`    \u2193 ${action.file_path}`), chalk.gray("used cloud"));
+                            pulled++;
+                        }
+                    }
+                    catch (err) {
+                        console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                        errors++;
+                    }
+                }
+                else if (resolution === "merge" && action.config_id) {
+                    const local = localByKey.get(key);
+                    if (local) {
+                        try {
+                            const cloudConfig = await getClient().configs.get(action.config_id);
+                            console.log(chalk.gray(`    Merging with LLM...`));
+                            const merged = await mergeConfigs(action.agent, action.file_path, local.content, cloudConfig.content);
+                            if (merged) {
+                                // Write merged to local
+                                const writePath = resolveWritePath(action.agent, action.file_path, action.scope);
+                                if (writePath) {
+                                    mkdirSync(dirname(writePath), { recursive: true });
+                                    writeFileSync(writePath, merged);
+                                }
+                                // Push merged to cloud
+                                await getClient().configs.upsert({
+                                    agent: action.agent,
+                                    file_path: action.file_path,
+                                    scope: action.scope,
+                                    content: merged,
+                                });
+                                console.log(chalk.magenta(`    \u2194 ${action.file_path}`), chalk.gray("merged (LLM)"));
+                                pushed++;
+                            }
+                            else {
+                                skipped++;
+                            }
+                        }
+                        catch (err) {
+                            console.log(chalk.red(`    \u2717 ${action.file_path}`), chalk.gray(err.message));
+                            errors++;
+                        }
+                    }
+                }
+                else {
+                    console.log(chalk.gray(`    - ${action.file_path}`), chalk.gray("skipped"));
+                    skipped++;
+                }
             }
         }
     }
-    console.log(chalk.blue(`Synced ${found.length} files to Memax`), chalk.gray(`(${synced} new, ${unchanged} unchanged${errors > 0 ? `, ${errors} errors` : ""})`));
+    // Summary
+    if (pushed === 0 &&
+        pulled === 0 &&
+        unchangedCount === 0 &&
+        skipped === 0 &&
+        errors === 0) {
+        console.log(chalk.gray("  No configs in cloud yet. Push some first from a device that has them.\n"));
+        return;
+    }
+    const parts = [];
+    if (pushed > 0)
+        parts.push(`${pushed} pushed`);
+    if (pulled > 0)
+        parts.push(`${pulled} restored`);
+    if (unchangedCount > 0)
+        parts.push(`${unchangedCount} unchanged`);
+    if (skipped > 0)
+        parts.push(`${skipped} skipped`);
+    if (errors > 0)
+        parts.push(`${errors} errors`);
+    console.log(chalk.bold(`\n  Done: ${parts.join(", ")}`));
+    if (pulled > 0) {
+        console.log(chalk.gray("  Restart your agents for restored configs to take effect."));
+    }
+    console.log();
+}
+function formatAgentName(id) {
+    const names = {
+        "claude-code": "Claude Code",
+        cursor: "Cursor",
+        codex: "Codex",
+        gemini: "Gemini CLI",
+        copilot: "GitHub Copilot",
+        windsurf: "Windsurf",
+        openclaw: "OpenClaw",
+        opencode: "OpenCode",
+        generic: "Generic",
+    };
+    return names[id] ?? id;
+}
+async function promptConflict(_agent, filePath) {
+    const answer = await ask(chalk.yellow(`\n    ${filePath} has changes on both sides.\n` +
+        `    [l] Keep local  [c] Use cloud  [m] Merge (LLM)  [s] Skip: `));
+    const a = answer.toLowerCase();
+    if (a === "l")
+        return "local";
+    if (a === "c")
+        return "cloud";
+    if (a === "m")
+        return "merge";
+    return "skip";
+}
+async function mergeConfigs(agent, filePath, localContent, cloudContent) {
+    try {
+        const result = await getClient().configs.merge({
+            local_content: localContent,
+            cloud_content: cloudContent,
+            file_path: filePath,
+            agent,
+        });
+        return result.merged_content;
+    }
+    catch (err) {
+        console.log(chalk.red(`    Merge failed: ${err.message}`));
+        return null;
+    }
 }
 //# sourceMappingURL=sync.js.map