studiograph 1.1.2 → 1.2.0-beta.1

package/dist/agent/tools/sync-tools.js

@@ -0,0 +1,691 @@
+/**
+ * Sync & Enrich Tools for Studiograph Agent
+ *
+ * These tools allow the agent to orchestrate sync and enrich operations:
+ * - Run the sync pipeline, apply staging, commit
+ * - Run LLM enrichment on entities
+ * - Manage source configs
+ */
+import { Type as T } from '@sinclair/typebox';
+import { spawnSync } from 'child_process';
+import { gitPush, gitPull } from '../../utils/git.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { runSync } from '../../services/sync/sync-runner.js';
+import { commitStaging, applyStaging, commitRepos } from '../../services/sync/commit.js';
+import { runEnrichment } from '../../services/sync/enrichment.js';
+import { StagingManager } from '../../services/sync/staging.js';
+import { SourceConfigManager } from '../../services/sync/source-config.js';
+import { ConnectorManager } from '../../mcp/connector-manager.js';
+import { SOURCE_DEFINITIONS } from '../../services/sync/source-definitions/definitions.js';
+import { wrapToolResult } from './graph-tools.js';
+import { VectorService } from '../../services/vector-service.js';
+import { BaseGraphManager } from '../../core/graph.js';
+import { loadUserConfig } from '../../core/user-config.js';
+/**
+ * Create sync tools for the agent
+ */
+export function createSyncTools(workspacePath, workspaceConfig) {
+    return [
+        // Run sync pipeline
+        {
+            name: 'sync_run',
+            label: 'Run Sync',
+            description: 'Run the sync pipeline to extract data from external sources into staging. Review with sync_status before committing.',
+            parameters: T.Object({
+                sources: T.Optional(T.Array(T.String(), { description: 'Source names to sync (default: all enabled)' })),
+                dryRun: T.Optional(T.Boolean({ description: 'Preview without writing staging files' })),
+                incremental: T.Optional(T.Boolean({ description: 'Only sync records updated since last sync' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const progress = [];
+                    const result = await runSync({
+                        workspacePath,
+                        sources: params.sources,
+                        dryRun: params.dryRun,
+                        incremental: params.incremental,
+                        schemaExtensions: workspaceConfig.schema_extensions,
+                    }, (msg) => progress.push(msg));
+                    return wrapToolResult({
+                        success: true,
+                        result,
+                        progress: progress.join('\n'),
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Check staging status
+        {
+            name: 'sync_status',
+            label: 'Sync Status',
+            description: 'Check what is currently in staging (pending review). Shows counts of creates, updates, and skips by entity type.',
+            parameters: T.Object({}),
+            execute: async (toolCallId, params) => {
+                try {
+                    const staging = new StagingManager(workspacePath);
+                    const summary = staging.getSummary();
+                    return wrapToolResult({
+                        success: true,
+                        hasStaging: summary.total > 0,
+                        summary,
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Apply staging to entity files (no git)
+        {
+            name: 'sync_apply',
+            label: 'Apply Staging',
+            description: 'Apply staging files to the knowledge graph (writes entity files, does not git commit). Always confirm with the user before calling this.',
+            parameters: T.Object({
+                force: T.Optional(T.Boolean({ description: 'Force apply even with uncommitted changes in repos' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const progress = [];
+                    const result = await applyStaging(workspacePath, (msg) => progress.push(msg), { force: params.force });
+                    return wrapToolResult({
+                        success: true,
+                        result: { created: result.created, updated: result.updated, skipped: result.skipped },
+                        progress: progress.join('\n'),
+                        nextSteps: 'Review changes with workspace_review, then commit with workspace_commit or studiograph commit',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Git commit across workspace repos
+        {
+            name: 'workspace_commit',
+            label: 'Commit Changes',
+            description: 'Git commit entity changes across all workspace repos. Works after sync_apply, enrich_run, or manual edits. Always confirm with the user before calling this.',
+            parameters: T.Object({
+                messagePrefix: T.Optional(T.String({ description: 'Commit message prefix (default: "update")' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const progress = [];
+                    await commitRepos(workspacePath, (msg) => progress.push(msg), { messagePrefix: params.messagePrefix ?? 'update' });
+                    return wrapToolResult({
+                        success: true,
+                        progress: progress.join('\n'),
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Commit staging to graph (deprecated — kept for backwards compatibility)
+        {
+            name: 'sync_commit',
+            label: 'Commit Staging (deprecated)',
+            description: 'DEPRECATED: Use sync_apply then workspace_commit instead. Commits staging files and auto git-commits.',
+            parameters: T.Object({
+                force: T.Optional(T.Boolean({ description: 'Force commit even with uncommitted changes in repos' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const progress = [];
+                    progress.push('Note: sync_commit is deprecated. Use sync_apply then workspace_commit instead.');
+                    const result = await commitStaging(workspacePath, (msg) => progress.push(msg), { force: params.force, noGit: false });
+                    return wrapToolResult({
+                        success: true,
+                        result,
+                        progress: progress.join('\n'),
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Abort staging
+        {
+            name: 'sync_abort',
+            label: 'Abort Staging',
+            description: 'Discard all staging files without committing.',
+            parameters: T.Object({}),
+            execute: async (toolCallId, params) => {
+                try {
+                    const staging = new StagingManager(workspacePath);
+                    const hadStaging = staging.hasStaging();
+                    staging.clear();
+                    return wrapToolResult({
+                        success: true,
+                        hadStaging,
+                        message: hadStaging ? 'Staging cleared.' : 'No staging files to clear.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // List sources and connectors
+        {
+            name: 'sync_list_sources',
+            label: 'List Sync Sources',
+            description: 'Read sync source configurations. Returns full source configs with entity_mappings, field maps, transforms, and all settings. Also lists available connectors and known source definitions. Use this whenever users ask about their source config.',
+            parameters: T.Object({}),
+            execute: async (toolCallId, params) => {
+                try {
+                    const configMgr = new SourceConfigManager(workspacePath);
+                    const sources = configMgr.getAll();
+                    // Load connectors but strip sensitive fields
+                    const connectors = ConnectorManager.loadConfigs().map(c => ({
+                        name: c.name,
+                        type: c.type,
+                        description: c.description,
+                    }));
+                    const availableDefinitions = Object.keys(SOURCE_DEFINITIONS);
+                    return wrapToolResult({
+                        success: true,
+                        sources,
+                        connectors,
+                        availableDefinitions,
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Set up a new source
+        {
+            name: 'sync_setup_source',
+            label: 'Setup Sync Source',
+            description: 'Add or reconfigure a sync source. Uses default mappings from source definitions when available.',
+            parameters: T.Object({
+                name: T.String({ description: 'Source name (lowercase, alphanumeric, hyphens/underscores)' }),
+                connector: T.Optional(T.String({ description: 'Connector name (defaults to source name)' })),
+                entity_mappings: T.Optional(T.Array(T.Object({}, { additionalProperties: true }), { description: 'Entity mappings (overrides defaults from source definition)' })),
+                force: T.Optional(T.Boolean({ description: 'Overwrite existing source config' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const configMgr = new SourceConfigManager(workspacePath);
+                    const connectorName = params.connector ?? params.name;
+                    // Check if source already exists
+                    const existing = configMgr.get(params.name);
+                    if (existing && !params.force) {
+                        return wrapToolResult({
+                            success: false,
+                            error: `Source "${params.name}" already exists. Use force: true to overwrite.`,
+                        });
+                    }
+                    // Verify connector exists
+                    const connectors = ConnectorManager.loadConfigs();
+                    const connector = connectors.find(c => c.name === connectorName);
+                    if (!connector) {
+                        return wrapToolResult({
+                            success: false,
+                            error: `Connector "${connectorName}" not found. Set up the connector first using the CLI: studiograph connector add ${connectorName}`,
+                            availableConnectors: connectors.map(c => c.name),
+                        });
+                    }
+                    // Build source config
+                    const definition = SOURCE_DEFINITIONS[params.name] ?? SOURCE_DEFINITIONS[connectorName];
+                    const mappings = params.entity_mappings ?? definition?.defaultMappings ?? [];
+                    const config = {
+                        name: params.name,
+                        connector: connectorName,
+                        enabled: true,
+                        added_at: new Date().toISOString(),
+                        entity_mappings: mappings,
+                    };
+                    // Validate
+                    const validation = configMgr.validate(config);
+                    if (!validation.valid) {
+                        return wrapToolResult({
+                            success: false,
+                            error: 'Invalid source config',
+                            validationErrors: validation.errors,
+                        });
+                    }
+                    configMgr.save(config);
+                    return wrapToolResult({
+                        success: true,
+                        message: `Source "${params.name}" configured with ${mappings.length} entity mapping(s).`,
+                        config,
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Remove a source
+        {
+            name: 'sync_remove_source',
+            label: 'Remove Sync Source',
+            description: 'Remove a sync source configuration.',
+            parameters: T.Object({
+                name: T.String({ description: 'Source name to remove' }),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const configMgr = new SourceConfigManager(workspacePath);
+                    const removed = configMgr.remove(params.name);
+                    return wrapToolResult({
+                        success: true,
+                        removed,
+                        message: removed
+                            ? `Source "${params.name}" removed.`
+                            : `Source "${params.name}" not found.`,
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // ── Enrich tools ──────────────────────────────────────────────────────────
+        // Run enrichment
+        {
+            name: 'enrich_run',
+            label: 'Enrich Entities',
+            description: 'Enrich entities with cross-source context via LLM. Writes changes in-place (no staging). Review with workspace_review, then commit with workspace_commit. Always confirm with the user before calling this.',
+            parameters: T.Object({
+                entityTypes: T.Optional(T.Array(T.String(), { description: 'Only enrich specific entity types' })),
+                dryRun: T.Optional(T.Boolean({ description: 'Preview without writing changes' })),
+                minRefs: T.Optional(T.Number({ description: 'Minimum context references required (default: 2)' })),
+                maxCompleteness: T.Optional(T.Number({ description: 'Maximum completeness to qualify (default: 0.6)' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const progress = [];
+                    const result = await runEnrichment({
+                        workspacePath,
+                        entityTypes: params.entityTypes,
+                        dryRun: params.dryRun,
+                        minRefs: params.minRefs,
+                        maxCompleteness: params.maxCompleteness,
+                        schemaExtensions: workspaceConfig.schema_extensions,
+                    }, (msg) => progress.push(msg));
+                    return wrapToolResult({
+                        success: true,
+                        result,
+                        progress: progress.join('\n'),
+                        nextSteps: result.enriched > 0 && !params.dryRun
+                            ? 'Review changes with workspace_review, then commit with workspace_commit or studiograph commit'
+                            : undefined,
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Abort enrichment (revert uncommitted changes)
+        {
+            name: 'enrich_abort',
+            label: 'Abort Enrichment',
+            description: 'Discard uncommitted enrichment changes by reverting all entity files (git checkout + git clean).',
+            parameters: T.Object({}),
+            execute: async (toolCallId, _params) => {
+                try {
+                    const repos = workspaceConfig.repos ?? [];
+                    const reverted = [];
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        spawnSync('git', ['checkout', '--', '.'], { cwd: repoPath, encoding: 'utf-8' });
+                        spawnSync('git', ['clean', '-fd'], { cwd: repoPath, encoding: 'utf-8' });
+                        reverted.push(repo.name);
+                    }
+                    return wrapToolResult({
+                        success: true,
+                        reverted,
+                        message: reverted.length > 0
+                            ? `Reverted changes in: ${reverted.join(', ')}`
+                            : 'No changes to revert.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: String(error instanceof Error ? error.message : error),
+                    });
+                }
+            },
+        },
+        // Reset workspace (discard uncommitted changes)
+        {
+            name: 'workspace_reset',
+            label: 'Reset Workspace',
+            description: 'Discard ALL uncommitted changes across workspace repos: reverts modified files (git checkout) and removes untracked files (git clean -fd). Also clears staging if present. This is destructive — always confirm with the user before calling.',
+            parameters: T.Object({}),
+            execute: async (toolCallId, _params) => {
+                try {
+                    const repos = workspaceConfig.repos ?? [];
+                    const resetRepos = [];
+                    const details = [];
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        // Check if there are changes to reset
+                        const status = spawnSync('git', ['status', '--porcelain'], { cwd: repoPath, encoding: 'utf-8' });
+                        if (status.status !== 0 || !status.stdout.trim())
+                            continue;
+                        const fileCount = status.stdout.trim().split('\n').length;
+                        // Revert tracked file changes
+                        spawnSync('git', ['checkout', '--', '.'], { cwd: repoPath, encoding: 'utf-8' });
+                        // Remove untracked files and directories
+                        spawnSync('git', ['clean', '-fd'], { cwd: repoPath, encoding: 'utf-8' });
+                        resetRepos.push(repo.name);
+                        details.push(`${repo.name}: ${fileCount} file(s) reset`);
+                    }
+                    // Clear staging too
+                    let clearedStaging = false;
+                    try {
+                        const staging = new StagingManager(workspacePath);
+                        if (staging.hasStaging()) {
+                            staging.clear();
+                            clearedStaging = true;
+                        }
+                    }
+                    catch { /* staging dir may not exist */ }
+                    const parts = [];
+                    if (resetRepos.length > 0)
+                        parts.push(`Reset ${resetRepos.length} repo(s): ${resetRepos.join(', ')}`);
+                    if (clearedStaging)
+                        parts.push('Cleared staging');
+                    return wrapToolResult({
+                        success: true,
+                        resetRepos,
+                        details,
+                        clearedStaging,
+                        message: parts.length > 0 ? parts.join('. ') + '.' : 'No changes to reset.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: String(error instanceof Error ? error.message : error),
+                    });
+                }
+            },
+        },
+        // Reindex search
+        {
+            name: 'workspace_reindex',
+            label: 'Reindex Search',
+            description: 'Rebuild the search index (LanceDB) for all workspace repos. Run after sync, enrich, or manual entity edits to update search results.',
+            parameters: T.Object({
+                repo: T.Optional(T.String({ description: 'Reindex a single repo only' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const userConfig = loadUserConfig();
+                    const dbPath = userConfig.vector_db_path || join(homedir(), '.studiograph', 'vector');
+                    const vectorService = new VectorService(dbPath, userConfig.voyage_api_key);
+                    await vectorService.init();
+                    const allRepos = workspaceConfig.repos ?? [];
+                    const repos = params.repo
+                        ? allRepos.filter(r => r.name === params.repo)
+                        : allRepos;
+                    if (params.repo && repos.length === 0) {
+                        return wrapToolResult({
+                            success: false,
+                            error: `Repo "${params.repo}" not found in workspace`,
+                            availableRepos: allRepos.map(r => r.name),
+                        });
+                    }
+                    const repoResults = {};
+                    let totalIndexed = 0;
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        try {
+                            const graph = new BaseGraphManager({
+                                repoPath,
+                                repoName: repo.name,
+                                gitUser: { id: 'reindex', name: 'reindex', email: 'reindex@studiograph.local' },
+                            });
+                            const entities = graph.list();
+                            if (entities.length > 0) {
+                                await vectorService.upsertMany(repo.name, entities);
+                            }
+                            vectorService.setLastIndexedTime(repo.name);
+                            repoResults[repo.name] = entities.length;
+                            totalIndexed += entities.length;
+                        }
+                        catch (err) {
+                            repoResults[repo.name] = -1; // signal failure
+                        }
+                    }
+                    return wrapToolResult({
+                        success: true,
+                        indexed: totalIndexed,
+                        repos: repoResults,
+                        message: `Indexed ${totalIndexed} entities across ${repos.length} repo(s)`,
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // ── Graph status & review ─────────────────────────────────────────────────
+        // Show changed files across repos
+        {
+            name: 'workspace_status',
+            label: 'Workspace Status',
+            description: 'Show uncommitted git changes across all workspace repos. Use this when users ask about pending changes, what files are modified, or whether there are changes ready to commit.',
+            parameters: T.Object({}),
+            execute: async (toolCallId, params) => {
+                try {
+                    const repos = workspaceConfig.repos ?? [];
+                    const changes = {};
+                    let totalChanged = 0;
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        const result = spawnSync('git', ['status', '--porcelain'], { cwd: repoPath, encoding: 'utf-8' });
+                        if (result.status === 0 && result.stdout.trim()) {
+                            const files = result.stdout.trim().split('\n').filter(Boolean);
+                            changes[repo.name] = files;
+                            totalChanged += files.length;
+                        }
+                    }
+                    return wrapToolResult({
+                        success: true,
+                        totalChanged,
+                        changes,
+                        message: totalChanged > 0
+                            ? `${totalChanged} file${totalChanged === 1 ? '' : 's'} changed across ${Object.keys(changes).length} repo${Object.keys(changes).length === 1 ? '' : 's'}`
+                            : 'No uncommitted changes.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Show diffs for review
+        {
+            name: 'workspace_review',
+            label: 'Review Changes',
+            description: 'Show git diffs for uncommitted entity changes across workspace repos. Use this to preview what will be committed. Optionally filter by entity type or specific file path.',
+            parameters: T.Object({
+                entityType: T.Optional(T.String({ description: 'Filter diff to a specific entity type (e.g. "person", "deal")' })),
+                file: T.Optional(T.String({ description: 'Show diff for a specific file path' })),
+                committed: T.Optional(T.Boolean({ description: 'Review last commit instead of uncommitted changes' })),
+            }),
+            execute: async (toolCallId, params) => {
+                try {
+                    const repos = workspaceConfig.repos ?? [];
+                    const diffArgs = params.committed
+                        ? ['diff', 'HEAD~1..HEAD']
+                        : ['diff'];
+                    const diffs = {};
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        const args = [...diffArgs];
+                        if (params.file) {
+                            args.push('--', params.file);
+                        }
+                        else if (params.entityType) {
+                            args.push('--', `${params.entityType}/`);
+                        }
+                        const result = spawnSync('git', args, { cwd: repoPath, encoding: 'utf-8' });
+                        if (result.status === 0 && result.stdout.trim()) {
+                            // Truncate very large diffs to avoid overwhelming the context
+                            const diff = result.stdout;
+                            diffs[repo.name] = diff.length > 10000
+                                ? diff.slice(0, 10000) + '\n\n... (truncated, use --file for specific entities)'
+                                : diff;
+                        }
+                    }
+                    return wrapToolResult({
+                        success: true,
+                        hasDiffs: Object.keys(diffs).length > 0,
+                        diffs,
+                        message: Object.keys(diffs).length > 0
+                            ? `Diffs from ${Object.keys(diffs).length} repo(s)`
+                            : 'No changes found.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Push all repos
+        {
+            name: 'workspace_push',
+            label: 'Push Repos',
+            description: 'Git push all workspace repos to their remotes. Always confirm with the user before calling this.',
+            parameters: T.Object({}),
+            execute: async (_toolCallId, _params) => {
+                try {
+                    const repos = workspaceConfig.repos ?? [];
+                    const results = {};
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        try {
+                            results[repo.name] = gitPush(repoPath);
+                        }
+                        catch (err) {
+                            results[repo.name] = `error: ${err instanceof Error ? err.message : String(err)}`;
+                        }
+                    }
+                    const pushed = Object.values(results).filter(r => r === 'pushed').length;
+                    return wrapToolResult({
+                        success: true,
+                        results,
+                        message: pushed > 0
+                            ? `Pushed ${pushed} repo${pushed === 1 ? '' : 's'}`
+                            : 'All repos already up to date.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+        // Pull all repos
+        {
+            name: 'workspace_pull',
+            label: 'Pull Repos',
+            description: 'Git pull all workspace repos from their remotes. Reports conflicts if any.',
+            parameters: T.Object({}),
+            execute: async (_toolCallId, _params) => {
+                try {
+                    const repos = workspaceConfig.repos ?? [];
+                    const results = {};
+                    for (const repo of repos) {
+                        const repoPath = join(workspacePath, repo.path);
+                        if (!existsSync(repoPath))
+                            continue;
+                        try {
+                            results[repo.name] = gitPull(repoPath);
+                        }
+                        catch (err) {
+                            results[repo.name] = `error: ${err instanceof Error ? err.message : String(err)}`;
+                        }
+                    }
+                    const updated = Object.values(results).filter(r => r === 'updated').length;
+                    const conflicts = Object.values(results).filter(r => r === 'conflict').length;
+                    return wrapToolResult({
+                        success: conflicts === 0,
+                        results,
+                        message: conflicts > 0
+                            ? `${conflicts} repo${conflicts === 1 ? '' : 's'} with merge conflicts — resolve manually`
+                            : updated > 0
+                                ? `Pulled updates in ${updated} repo${updated === 1 ? '' : 's'}`
+                                : 'All repos already up to date.',
+                    });
+                }
+                catch (error) {
+                    return wrapToolResult({
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            },
+        },
+    ];
+}
+//# sourceMappingURL=sync-tools.js.map