opencode-synced 0.4.0 → 0.4.1

package/dist/sync/repo.js

@@ -0,0 +1,248 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { pathExists } from './config.js';
+import { RepoDivergedError, RepoPrivateRequiredError, RepoVisibilityError, SyncCommandError, } from './errors.js';
+export async function isRepoCloned(repoDir) {
+    const gitDir = path.join(repoDir, '.git');
+    return pathExists(gitDir);
+}
+export function resolveRepoIdentifier(config) {
+    const repo = config.repo;
+    if (!repo) {
+        throw new SyncCommandError('Missing repo configuration.');
+    }
+    if (repo.url)
+        return repo.url;
+    if (repo.owner && repo.name)
+        return `${repo.owner}/${repo.name}`;
+    throw new SyncCommandError('Repo configuration must include url or owner/name.');
+}
+export function resolveRepoBranch(config, fallback = 'main') {
+    const branch = config.repo?.branch;
+    if (branch)
+        return branch;
+    return fallback;
+}
+export async function ensureRepoCloned($, config, repoDir) {
+    if (await isRepoCloned(repoDir)) {
+        return;
+    }
+    await fs.mkdir(path.dirname(repoDir), { recursive: true });
+    const repoIdentifier = resolveRepoIdentifier(config);
+    try {
+        await $ `gh repo clone ${repoIdentifier} ${repoDir}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to clone repo: ${formatError(error)}`);
+    }
+}
+export async function ensureRepoPrivate($, config) {
+    const repoIdentifier = resolveRepoIdentifier(config);
+    let output;
+    try {
+        output = await $ `gh repo view ${repoIdentifier} --json isPrivate`.quiet().text();
+    }
+    catch (error) {
+        throw new RepoVisibilityError(`Unable to verify repo visibility: ${formatError(error)}`);
+    }
+    let isPrivate = false;
+    try {
+        isPrivate = parseRepoVisibility(output);
+    }
+    catch (error) {
+        throw new RepoVisibilityError(`Unable to verify repo visibility: ${formatError(error)}`);
+    }
+    if (!isPrivate) {
+        throw new RepoPrivateRequiredError('Secrets sync requires a private GitHub repo.');
+    }
+}
+export function parseRepoVisibility(output) {
+    const parsed = JSON.parse(output);
+    if (typeof parsed.isPrivate !== 'boolean') {
+        throw new Error('Invalid repo visibility response.');
+    }
+    return parsed.isPrivate;
+}
+export async function fetchAndFastForward($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} fetch --prune`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to fetch repo: ${formatError(error)}`);
+    }
+    await checkoutBranch($, repoDir, branch);
+    const remoteRef = `origin/${branch}`;
+    const remoteExists = await hasRemoteRef($, repoDir, branch);
+    if (!remoteExists) {
+        return { updated: false, branch };
+    }
+    const { ahead, behind } = await getAheadBehind($, repoDir, remoteRef);
+    if (ahead > 0 && behind > 0) {
+        throw new RepoDivergedError(`Local sync repo has diverged. Resolve with: cd ${repoDir} && git status && git pull --rebase`);
+    }
+    if (behind > 0) {
+        try {
+            await $ `git -C ${repoDir} merge --ff-only ${remoteRef}`.quiet();
+            return { updated: true, branch };
+        }
+        catch (error) {
+            throw new SyncCommandError(`Failed to fast-forward: ${formatError(error)}`);
+        }
+    }
+    return { updated: false, branch };
+}
+export async function getRepoStatus($, repoDir) {
+    const branch = await getCurrentBranch($, repoDir);
+    const changes = await getStatusLines($, repoDir);
+    return { branch, changes };
+}
+export async function hasLocalChanges($, repoDir) {
+    const lines = await getStatusLines($, repoDir);
+    return lines.length > 0;
+}
+export async function commitAll($, repoDir, message) {
+    try {
+        await $ `git -C ${repoDir} add -A`.quiet();
+        await $ `git -C ${repoDir} commit -m ${message}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to commit changes: ${formatError(error)}`);
+    }
+}
+export async function pushBranch($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} push -u origin ${branch}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to push changes: ${formatError(error)}`);
+    }
+}
+async function getCurrentBranch($, repoDir) {
+    try {
+        const output = await $ `git -C ${repoDir} rev-parse --abbrev-ref HEAD`.quiet().text();
+        const branch = output.trim();
+        if (!branch || branch === 'HEAD')
+            return 'main';
+        return branch;
+    }
+    catch {
+        return 'main';
+    }
+}
+async function checkoutBranch($, repoDir, branch) {
+    const exists = await hasLocalBranch($, repoDir, branch);
+    try {
+        if (exists) {
+            await $ `git -C ${repoDir} checkout ${branch}`.quiet();
+            return;
+        }
+        await $ `git -C ${repoDir} checkout -b ${branch}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to checkout branch: ${formatError(error)}`);
+    }
+}
+async function hasLocalBranch($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} show-ref --verify refs/heads/${branch}`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasRemoteRef($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} show-ref --verify refs/remotes/origin/${branch}`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getAheadBehind($, repoDir, remoteRef) {
+    try {
+        const output = await $ `git -C ${repoDir} rev-list --left-right --count HEAD...${remoteRef}`
+            .quiet()
+            .text();
+        const [aheadRaw, behindRaw] = output.trim().split(/\s+/);
+        const ahead = Number(aheadRaw ?? 0);
+        const behind = Number(behindRaw ?? 0);
+        return { ahead, behind };
+    }
+    catch {
+        return { ahead: 0, behind: 0 };
+    }
+}
+async function getStatusLines($, repoDir) {
+    try {
+        const output = await $ `git -C ${repoDir} status --porcelain`.quiet().text();
+        return output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function formatError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export async function repoExists($, repoIdentifier) {
+    try {
+        await $ `gh repo view ${repoIdentifier} --json name`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getAuthenticatedUser($) {
+    try {
+        const output = await $ `gh api user --jq .login`.quiet().text();
+        return output.trim();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to detect GitHub user. Ensure gh is authenticated: ${formatError(error)}`);
+    }
+}
+const LIKELY_SYNC_REPO_NAMES = [
+    'my-opencode-config',
+    'opencode-config',
+    'opencode-sync',
+    'opencode-synced',
+    'dotfiles-opencode',
+];
+export async function findSyncRepo($, repoName) {
+    const owner = await getAuthenticatedUser($);
+    // If user provided a specific name, check that first
+    if (repoName) {
+        const exists = await repoExists($, `${owner}/${repoName}`);
+        if (exists) {
+            const isPrivate = await checkRepoPrivate($, `${owner}/${repoName}`);
+            return { owner, name: repoName, isPrivate };
+        }
+        return null;
+    }
+    // Search through likely repo names
+    for (const name of LIKELY_SYNC_REPO_NAMES) {
+        const exists = await repoExists($, `${owner}/${name}`);
+        if (exists) {
+            const isPrivate = await checkRepoPrivate($, `${owner}/${name}`);
+            return { owner, name, isPrivate };
+        }
+    }
+    return null;
+}
+async function checkRepoPrivate($, repoIdentifier) {
+    try {
+        const output = await $ `gh repo view ${repoIdentifier} --json isPrivate`.quiet().text();
+        return parseRepoVisibility(output);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sync/service.js

@@ -0,0 +1,453 @@
+import { syncLocalToRepo, syncRepoToLocal } from './apply.js';
+import { generateCommitMessage } from './commit.js';
+import { loadOverrides, loadState, loadSyncConfig, normalizeSyncConfig, writeState, writeSyncConfig, } from './config.js';
+import { SyncCommandError, SyncConfigMissingError } from './errors.js';
+import { buildSyncPlan, resolveRepoRoot, resolveSyncLocations } from './paths.js';
+import { commitAll, ensureRepoCloned, ensureRepoPrivate, fetchAndFastForward, findSyncRepo, getAuthenticatedUser, getRepoStatus, hasLocalChanges, isRepoCloned, pushBranch, repoExists, resolveRepoBranch, resolveRepoIdentifier, } from './repo.js';
+import { createLogger, extractTextFromResponse, resolveSmallModel, showToast, unwrapData, } from './utils.js';
+export function createSyncService(ctx) {
+    const locations = resolveSyncLocations();
+    const log = createLogger(ctx.client);
+    return {
+        startupSync: async () => {
+            const config = await loadSyncConfig(locations);
+            if (!config) {
+                await showToast(ctx.client, 'Configure opencode-synced with /sync-init.', 'info');
+                return;
+            }
+            try {
+                await runStartup(ctx, locations, config, log);
+            }
+            catch (error) {
+                log.error('Startup sync failed', { error: formatError(error) });
+                await showToast(ctx.client, formatError(error), 'error');
+            }
+        },
+        status: async () => {
+            const config = await loadSyncConfig(locations);
+            if (!config) {
+                return 'opencode-synced is not configured. Run /sync-init to set it up.';
+            }
+            const repoRoot = resolveRepoRoot(config, locations);
+            const state = await loadState(locations);
+            let repoStatus = [];
+            let branch = resolveRepoBranch(config);
+            const cloned = await isRepoCloned(repoRoot);
+            if (!cloned) {
+                repoStatus = ['Repo not cloned'];
+            }
+            else {
+                try {
+                    const status = await getRepoStatus(ctx.$, repoRoot);
+                    repoStatus = status.changes;
+                    branch = status.branch;
+                }
+                catch {
+                    repoStatus = ['Repo status unavailable'];
+                }
+            }
+            const repoIdentifier = resolveRepoIdentifier(config);
+            const includeSecrets = config.includeSecrets ? 'enabled' : 'disabled';
+            const includeSessions = config.includeSessions ? 'enabled' : 'disabled';
+            const includePromptStash = config.includePromptStash ? 'enabled' : 'disabled';
+            const lastPull = state.lastPull ?? 'never';
+            const lastPush = state.lastPush ?? 'never';
+            let changesLabel = 'clean';
+            if (!cloned) {
+                changesLabel = 'not cloned';
+            }
+            else if (repoStatus.length > 0) {
+                if (repoStatus[0] === 'Repo status unavailable') {
+                    changesLabel = 'unknown';
+                }
+                else {
+                    changesLabel = `${repoStatus.length} pending`;
+                }
+            }
+            const statusLines = [
+                `Repo: ${repoIdentifier}`,
+                `Branch: ${branch}`,
+                `Secrets: ${includeSecrets}`,
+                `Sessions: ${includeSessions}`,
+                `Prompt stash: ${includePromptStash}`,
+                `Last pull: ${lastPull}`,
+                `Last push: ${lastPush}`,
+                `Working tree: ${changesLabel}`,
+            ];
+            return statusLines.join('\n');
+        },
+        init: async (options) => {
+            const config = await buildConfigFromInit(ctx.$, options);
+            const repoIdentifier = resolveRepoIdentifier(config);
+            const isPrivate = options.private ?? true;
+            const exists = await repoExists(ctx.$, repoIdentifier);
+            let created = false;
+            if (!exists) {
+                await createRepo(ctx.$, config, isPrivate);
+                created = true;
+            }
+            await writeSyncConfig(locations, config);
+            const repoRoot = resolveRepoRoot(config, locations);
+            await ensureRepoCloned(ctx.$, config, repoRoot);
+            await ensureSecretsPolicy(ctx, config);
+            if (created) {
+                const overrides = await loadOverrides(locations);
+                const plan = buildSyncPlan(config, locations, repoRoot);
+                await syncLocalToRepo(plan, overrides);
+                const dirty = await hasLocalChanges(ctx.$, repoRoot);
+                if (dirty) {
+                    const branch = resolveRepoBranch(config);
+                    await commitAll(ctx.$, repoRoot, 'Initial sync from opencode-synced');
+                    await pushBranch(ctx.$, repoRoot, branch);
+                    await writeState(locations, { lastPush: new Date().toISOString() });
+                }
+            }
+            const lines = [
+                'opencode-synced configured.',
+                `Repo: ${repoIdentifier}${created ? ' (created)' : ''}`,
+                `Branch: ${resolveRepoBranch(config)}`,
+                `Local repo: ${repoRoot}`,
+            ];
+            return lines.join('\n');
+        },
+        link: async (options) => {
+            const found = await findSyncRepo(ctx.$, options.repo);
+            if (!found) {
+                const searchedFor = options.repo
+                    ? `"${options.repo}"`
+                    : 'common sync repo names (my-opencode-config, opencode-config, etc.)';
+                const lines = [
+                    `Could not find an existing sync repo. Searched for: ${searchedFor}`,
+                    '',
+                    'To link to an existing repo, run:',
+                    '  /sync-link <repo-name>',
+                    '',
+                    'To create a new sync repo, run:',
+                    '  /sync-init',
+                ];
+                return lines.join('\n');
+            }
+            const config = normalizeSyncConfig({
+                repo: { owner: found.owner, name: found.name },
+                includeSecrets: false,
+                includeSessions: false,
+                includePromptStash: false,
+                extraSecretPaths: [],
+            });
+            await writeSyncConfig(locations, config);
+            const repoRoot = resolveRepoRoot(config, locations);
+            await ensureRepoCloned(ctx.$, config, repoRoot);
+            const branch = await resolveBranch(ctx, config, repoRoot);
+            await fetchAndFastForward(ctx.$, repoRoot, branch);
+            const overrides = await loadOverrides(locations);
+            const plan = buildSyncPlan(config, locations, repoRoot);
+            await syncRepoToLocal(plan, overrides);
+            await writeState(locations, {
+                lastPull: new Date().toISOString(),
+                lastRemoteUpdate: new Date().toISOString(),
+            });
+            const lines = [
+                `Linked to existing sync repo: ${found.owner}/${found.name}`,
+                '',
+                'Your local OpenCode config has been OVERWRITTEN with the synced config.',
+                'Your local overrides file was preserved and applied on top.',
+                '',
+                'Restart OpenCode to apply the new settings.',
+                '',
+                found.isPrivate
+                    ? 'To enable secrets sync, run: /sync-enable-secrets'
+                    : 'Note: Repo is public. Secrets sync is disabled.',
+            ];
+            await showToast(ctx.client, 'Config synced. Restart OpenCode to apply.', 'info');
+            return lines.join('\n');
+        },
+        pull: async () => {
+            const config = await getConfigOrThrow(locations);
+            const repoRoot = resolveRepoRoot(config, locations);
+            await ensureRepoCloned(ctx.$, config, repoRoot);
+            await ensureSecretsPolicy(ctx, config);
+            const branch = await resolveBranch(ctx, config, repoRoot);
+            const dirty = await hasLocalChanges(ctx.$, repoRoot);
+            if (dirty) {
+                throw new SyncCommandError(`Local sync repo has uncommitted changes. Resolve in ${repoRoot} before pulling.`);
+            }
+            const update = await fetchAndFastForward(ctx.$, repoRoot, branch);
+            if (!update.updated) {
+                return 'Already up to date.';
+            }
+            const overrides = await loadOverrides(locations);
+            const plan = buildSyncPlan(config, locations, repoRoot);
+            await syncRepoToLocal(plan, overrides);
+            await writeState(locations, {
+                lastPull: new Date().toISOString(),
+                lastRemoteUpdate: new Date().toISOString(),
+            });
+            await showToast(ctx.client, 'Config updated. Restart OpenCode to apply.', 'info');
+            return 'Remote config applied. Restart OpenCode to use new settings.';
+        },
+        push: async () => {
+            const config = await getConfigOrThrow(locations);
+            const repoRoot = resolveRepoRoot(config, locations);
+            await ensureRepoCloned(ctx.$, config, repoRoot);
+            await ensureSecretsPolicy(ctx, config);
+            const branch = await resolveBranch(ctx, config, repoRoot);
+            const preDirty = await hasLocalChanges(ctx.$, repoRoot);
+            if (preDirty) {
+                throw new SyncCommandError(`Local sync repo has uncommitted changes. Resolve in ${repoRoot} before pushing.`);
+            }
+            const overrides = await loadOverrides(locations);
+            const plan = buildSyncPlan(config, locations, repoRoot);
+            await syncLocalToRepo(plan, overrides);
+            const dirty = await hasLocalChanges(ctx.$, repoRoot);
+            if (!dirty) {
+                return 'No local changes to push.';
+            }
+            const message = await generateCommitMessage({ client: ctx.client, $: ctx.$ }, repoRoot);
+            await commitAll(ctx.$, repoRoot, message);
+            await pushBranch(ctx.$, repoRoot, branch);
+            await writeState(locations, {
+                lastPush: new Date().toISOString(),
+            });
+            return `Pushed changes: ${message}`;
+        },
+        enableSecrets: async (extraSecretPaths) => {
+            const config = await getConfigOrThrow(locations);
+            config.includeSecrets = true;
+            if (extraSecretPaths) {
+                config.extraSecretPaths = extraSecretPaths;
+            }
+            await ensureRepoPrivate(ctx.$, config);
+            await writeSyncConfig(locations, config);
+            return 'Secrets sync enabled for this repo.';
+        },
+        resolve: async () => {
+            const config = await getConfigOrThrow(locations);
+            const repoRoot = resolveRepoRoot(config, locations);
+            await ensureRepoCloned(ctx.$, config, repoRoot);
+            const dirty = await hasLocalChanges(ctx.$, repoRoot);
+            if (!dirty) {
+                return 'No uncommitted changes to resolve.';
+            }
+            const status = await getRepoStatus(ctx.$, repoRoot);
+            const decision = await analyzeAndDecideResolution({ client: ctx.client, $: ctx.$ }, repoRoot, status.changes);
+            if (decision.action === 'commit') {
+                const message = decision.message ?? 'Sync: Auto-resolved uncommitted changes';
+                await commitAll(ctx.$, repoRoot, message);
+                return `Resolved by committing changes: ${message}`;
+            }
+            if (decision.action === 'reset') {
+                try {
+                    await ctx.$ `git -C ${repoRoot} reset --hard HEAD`.quiet();
+                    await ctx.$ `git -C ${repoRoot} clean -fd`.quiet();
+                    return 'Resolved by discarding all uncommitted changes.';
+                }
+                catch (error) {
+                    throw new SyncCommandError(`Failed to reset changes: ${formatError(error)}`);
+                }
+            }
+            return `Unable to automatically resolve. Please manually resolve in: ${repoRoot}`;
+        },
+    };
+}
+async function runStartup(ctx, locations, config, log) {
+    const repoRoot = resolveRepoRoot(config, locations);
+    log.debug('Starting sync', { repoRoot });
+    await ensureRepoCloned(ctx.$, config, repoRoot);
+    await ensureSecretsPolicy(ctx, config);
+    const branch = await resolveBranch(ctx, config, repoRoot);
+    log.debug('Resolved branch', { branch });
+    const dirty = await hasLocalChanges(ctx.$, repoRoot);
+    if (dirty) {
+        log.warn('Uncommitted changes detected', { repoRoot });
+        await showToast(ctx.client, `Uncommitted changes detected. Run /sync-resolve to auto-fix, or manually resolve in: ${repoRoot}`, 'warning');
+        return;
+    }
+    const update = await fetchAndFastForward(ctx.$, repoRoot, branch);
+    if (update.updated) {
+        log.info('Pulled remote changes', { branch });
+        const overrides = await loadOverrides(locations);
+        const plan = buildSyncPlan(config, locations, repoRoot);
+        await syncRepoToLocal(plan, overrides);
+        await writeState(locations, {
+            lastPull: new Date().toISOString(),
+            lastRemoteUpdate: new Date().toISOString(),
+        });
+        await showToast(ctx.client, 'Config updated. Restart OpenCode to apply.', 'info');
+        return;
+    }
+    const overrides = await loadOverrides(locations);
+    const plan = buildSyncPlan(config, locations, repoRoot);
+    await syncLocalToRepo(plan, overrides);
+    const changes = await hasLocalChanges(ctx.$, repoRoot);
+    if (!changes) {
+        log.debug('No local changes to push');
+        return;
+    }
+    const message = await generateCommitMessage({ client: ctx.client, $: ctx.$ }, repoRoot);
+    log.info('Pushing local changes', { message });
+    await commitAll(ctx.$, repoRoot, message);
+    await pushBranch(ctx.$, repoRoot, branch);
+    await writeState(locations, {
+        lastPush: new Date().toISOString(),
+    });
+}
+async function getConfigOrThrow(locations) {
+    const config = await loadSyncConfig(locations);
+    if (!config) {
+        throw new SyncConfigMissingError('Missing opencode-synced config. Run /sync-init to set it up.');
+    }
+    return config;
+}
+async function ensureSecretsPolicy(ctx, config) {
+    if (!config.includeSecrets)
+        return;
+    await ensureRepoPrivate(ctx.$, config);
+}
+async function resolveBranch(ctx, config, repoRoot) {
+    try {
+        const status = await getRepoStatus(ctx.$, repoRoot);
+        return resolveRepoBranch(config, status.branch);
+    }
+    catch {
+        return resolveRepoBranch(config);
+    }
+}
+const DEFAULT_REPO_NAME = 'my-opencode-config';
+async function buildConfigFromInit($, options) {
+    const repo = await resolveRepoFromInit($, options);
+    return normalizeSyncConfig({
+        repo,
+        includeSecrets: options.includeSecrets ?? false,
+        includeSessions: options.includeSessions ?? false,
+        includePromptStash: options.includePromptStash ?? false,
+        extraSecretPaths: options.extraSecretPaths ?? [],
+        localRepoPath: options.localRepoPath,
+    });
+}
+async function resolveRepoFromInit($, options) {
+    if (options.url) {
+        return { url: options.url, branch: options.branch };
+    }
+    if (options.owner && options.name) {
+        return { owner: options.owner, name: options.name, branch: options.branch };
+    }
+    if (options.repo) {
+        if (options.repo.includes('://') || options.repo.endsWith('.git')) {
+            return { url: options.repo, branch: options.branch };
+        }
+        if (options.repo.includes('/')) {
+            const [owner, name] = options.repo.split('/');
+            if (owner && name) {
+                return { owner, name, branch: options.branch };
+            }
+        }
+        const owner = await getAuthenticatedUser($);
+        return { owner, name: options.repo, branch: options.branch };
+    }
+    // Default: auto-detect owner, use default repo name
+    const owner = await getAuthenticatedUser($);
+    const name = DEFAULT_REPO_NAME;
+    return { owner, name, branch: options.branch };
+}
+async function createRepo($, config, isPrivate) {
+    const owner = config.repo?.owner;
+    const name = config.repo?.name;
+    if (!owner || !name) {
+        throw new SyncCommandError('Repo creation requires owner/name.');
+    }
+    const visibility = isPrivate ? '--private' : '--public';
+    try {
+        await $ `gh repo create ${owner}/${name} ${visibility} --confirm`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to create repo: ${formatError(error)}`);
+    }
+}
+function formatError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+async function analyzeAndDecideResolution(ctx, repoRoot, changes) {
+    try {
+        const diff = await ctx.$ `git -C ${repoRoot} diff HEAD`.quiet().text();
+        const statusOutput = changes.join('\n');
+        const prompt = [
+            'You are analyzing uncommitted changes in an opencode-synced repository.',
+            'Decide whether to commit these changes or discard them.',
+            '',
+            'IMPORTANT: Only choose "commit" if the changes appear to be legitimate config updates.',
+            'Choose "discard" if the changes look like temporary files, cache, or corruption.',
+            '',
+            'Respond with ONLY a JSON object in this exact format:',
+            '{"action": "commit", "message": "your commit message here"}',
+            'OR',
+            '{"action": "discard", "reason": "explanation why discarding"}',
+            '',
+            'Status:',
+            statusOutput,
+            '',
+            'Diff preview (first 2000 chars):',
+            diff.slice(0, 2000),
+        ].join('\n');
+        const model = await resolveSmallModel(ctx.client);
+        if (!model) {
+            return { action: 'manual', reason: 'No AI model available' };
+        }
+        let sessionId = null;
+        try {
+            const sessionResult = await ctx.client.session.create({
+                body: { title: 'sync-resolve' },
+            });
+            const session = unwrapData(sessionResult);
+            sessionId = session?.id ?? null;
+            if (!sessionId) {
+                return { action: 'manual', reason: 'Failed to create session' };
+            }
+            const response = await ctx.client.session.prompt({
+                path: { id: sessionId },
+                body: {
+                    model,
+                    parts: [{ type: 'text', text: prompt }],
+                },
+            });
+            const messageText = extractTextFromResponse(unwrapData(response) ?? response);
+            if (!messageText) {
+                return { action: 'manual', reason: 'No response from AI' };
+            }
+            const decision = parseResolutionDecision(messageText);
+            return decision;
+        }
+        finally {
+            if (sessionId) {
+                try {
+                    await ctx.client.session.delete({ path: { id: sessionId } });
+                }
+                catch { }
+            }
+        }
+    }
+    catch (error) {
+        console.error('[ERROR] AI resolution analysis failed:', error);
+        return { action: 'manual', reason: `Error analyzing changes: ${formatError(error)}` };
+    }
+}
+function parseResolutionDecision(text) {
+    try {
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return { action: 'manual', reason: 'Could not parse AI response' };
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (parsed.action === 'commit' && parsed.message) {
+            return { action: 'commit', message: parsed.message };
+        }
+        if (parsed.action === 'discard') {
+            return { action: 'reset', reason: parsed.reason };
+        }
+        return { action: 'manual', reason: 'Unexpected AI response format' };
+    }
+    catch {
+        return { action: 'manual', reason: 'Failed to parse AI decision' };
+    }
+}