studiograph 1.3.48-next.13 → 1.3.48-next.131

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

@@ -1,992 +0,0 @@
-/**
- * Sync & Workspace Tools for Studiograph Agent
- *
- * These tools allow the agent to:
- * - Sync external data into collections (collection-scoped sync)
- * - Refresh individual synced entities from their source
- * - Manage workspace git operations (commit, push, pull, status)
- * - Inspect MCP connectors for sync configuration
- */
-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 { commitRepos } from '../../services/sync/commit.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 { syncRepo, syncWorkspaceRule } from '../../services/sync/collection-sync.js';
-import { refreshEntity } from '../../services/sync/entity-refresh.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';
-export function createSyncTools(workspacePath, workspaceConfig, registryRef, getCurrentUser) {
-    const getUser = getCurrentUser ?? (() => null);
-    const getRegistry = () => registryRef?.registry ?? null;
-    function adminOnly() {
-        const user = getUser();
-        if (!user)
-            return null;
-        if (user.role === 'admin')
-            return null;
-        return 'Sync operations require admin access.';
-    }
-    return [
-        // ── Collection-scoped sync tools ─────────────────────────────────────────
-        // Sync a collection — runs collection-level rules AND workspace-level rules targeting it
-        {
-            name: 'sync_collection',
-            label: 'Sync Collection',
-            description: 'Pull new entities from external sources into a collection (admin only). Runs both collection-level sync rules and any workspace-level sync rules that target this collection. Creates new entities only — existing entities (matched by source_ref) are never updated. Always confirm with the user before calling.',
-            parameters: T.Object({
-                collection: T.String({ description: 'Collection name to sync' }),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    const denied = adminOnly();
-                    if (denied)
-                        return wrapToolResult({ success: false, error: denied });
-                    const progress = [];
-                    const { results } = await syncRepo({
-                        workspacePath,
-                        collectionName: params.collection,
-                        workspaceConfig,
-                        schemaExtensions: workspaceConfig.schema_extensions,
-                        onProgress: (msg) => progress.push(msg),
-                    });
-                    const totalCreated = results.reduce((s, r) => r.targets.reduce((ts, t) => ts + t.created + t.derived, 0) + s, 0);
-                    const totalSkipped = results.reduce((s, r) => r.targets.reduce((ts, t) => ts + t.skipped, 0) + s, 0);
-                    return wrapToolResult({
-                        success: true,
-                        results,
-                        summary: `Created ${totalCreated}, skipped ${totalSkipped}`,
-                        progress: progress.join('\n'),
-                        nextSteps: totalCreated > 0 ? 'Commit changes with workspace_commit' : undefined,
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                }
-            },
-        },
-        // Run all workspace-level sync rules
-        {
-            name: 'sync_workspace',
-            label: 'Sync Workspace',
-            description: 'Run all workspace-level sync rules (admin only). Each rule fetches from its source once and distributes records to multiple target collections.',
-            parameters: T.Object({}),
-            execute: async (toolCallId, _params) => {
-                try {
-                    const denied = adminOnly();
-                    if (denied)
-                        return wrapToolResult({ success: false, error: denied });
-                    const rules = workspaceConfig.sync ?? [];
-                    if (rules.length === 0) {
-                        return wrapToolResult({ success: true, results: [], summary: 'No workspace-level sync rules configured' });
-                    }
-                    const progress = [];
-                    const results = [];
-                    for (const rule of rules) {
-                        const result = await syncWorkspaceRule({
-                            workspacePath,
-                            rule,
-                            workspaceConfig,
-                            schemaExtensions: workspaceConfig.schema_extensions,
-                            onProgress: (msg) => progress.push(msg),
-                        });
-                        results.push(result);
-                    }
-                    const totalCreated = results.reduce((s, r) => r.targets.reduce((ts, t) => ts + t.created + t.derived, 0) + s, 0);
-                    return wrapToolResult({
-                        success: true,
-                        results,
-                        summary: `Ran ${rules.length} workspace rule(s), created ${totalCreated} entities`,
-                        progress: progress.join('\n'),
-                        nextSteps: totalCreated > 0 ? 'Commit changes with workspace_commit' : undefined,
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                }
-            },
-        },
-        // Refresh a single synced entity
-        {
-            name: 'sync_refresh',
-            label: 'Refresh Synced Entity',
-            description: 'Refresh a single entity from its external source (admin only). Shows what fields have changed.',
-            parameters: T.Object({
-                entity_id: T.String({ description: 'Entity ID to refresh' }),
-                collection: T.Optional(T.String({ description: 'Collection name (auto-detected if omitted)' })),
-                entity_type: T.Optional(T.String({ description: 'Entity type (auto-detected if omitted)' })),
-                apply: T.Optional(T.Boolean({ description: 'Apply changes immediately (default: false, just show diff)' })),
-            }),
-            execute: async (toolCallId, params) => {
-                const denied = adminOnly();
-                if (denied)
-                    return wrapToolResult({ success: false, error: denied });
-                try {
-                    let { collection, entity_type, entity_id, apply } = params;
-                    // Auto-detect collection and entity_type if not provided
-                    if (!collection || !entity_type) {
-                        for (const repo of workspaceConfig.repos) {
-                            try {
-                                const repoPath = join(workspacePath, repo.path);
-                                if (!existsSync(repoPath))
-                                    continue;
-                                const graph = new BaseGraphManager({
-                                    repoPath,
-                                    repoName: repo.name,
-                                    gitUser: { id: 'agent', name: 'Agent', email: 'agent@studiograph.local' },
-                                });
-                                const entities = graph.list();
-                                const match = entities.find(e => e.data?.entity_id === entity_id);
-                                if (match) {
-                                    collection = repo.name;
-                                    entity_type = match.entityType;
-                                    break;
-                                }
-                            }
-                            catch { /* skip */ }
-                        }
-                    }
-                    if (!collection || !entity_type) {
-                        return wrapToolResult({
-                            success: false,
-                            error: `Entity "${entity_id}" not found in any collection`,
-                        });
-                    }
-                    const result = await refreshEntity({
-                        workspacePath,
-                        collectionName: collection,
-                        entityType: entity_type,
-                        entityId: entity_id,
-                        workspaceConfig: workspaceConfig,
-                        schemaExtensions: workspaceConfig.schema_extensions,
-                        apply: apply ?? false,
-                    });
-                    if (result.diffs.length === 0 && !result.body_changed) {
-                        return wrapToolResult({
-                            success: true,
-                            message: 'Entity is already up to date with the source.',
-                            entity_id,
-                            source_ref: result.source_ref,
-                        });
-                    }
-                    return wrapToolResult({
-                        success: true,
-                        entity_id,
-                        source_ref: result.source_ref,
-                        applied: result.applied,
-                        changes: result.diffs.map(d => ({
-                            field: d.field,
-                            from: d.old_value,
-                            to: d.new_value,
-                        })),
-                        body_changed: result.body_changed,
-                        nextSteps: result.applied
-                            ? 'Changes applied. Commit with workspace_commit.'
-                            : 'Review the changes above and call sync_refresh with apply: true to apply them.',
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                }
-            },
-        },
-        // Show sync status across collections
-        {
-            name: 'sync_status',
-            label: 'Sync Status',
-            description: 'Show which collections have sync rules configured, their sources, and last sync time. Use this when users ask about sync configuration or what has been synced.',
-            parameters: T.Object({
-                collection: T.Optional(T.String({ description: 'Filter to a specific collection' })),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    const repos = params.collection
-                        ? workspaceConfig.repos.filter(r => r.name === params.collection)
-                        : workspaceConfig.repos;
-                    const collections = [];
-                    for (const repo of repos) {
-                        const syncRules = repo.sync;
-                        if (!syncRules || syncRules.length === 0)
-                            continue;
-                        let syncedCount = 0;
-                        let lastSync = null;
-                        try {
-                            const repoPath = join(workspacePath, repo.path);
-                            if (!existsSync(repoPath))
-                                continue;
-                            const graph = new BaseGraphManager({
-                                repoPath,
-                                repoName: repo.name,
-                                gitUser: { id: 'agent', name: 'Agent', email: 'agent@studiograph.local' },
-                            });
-                            for (const entity of graph.list()) {
-                                const syncedAt = entity.data?.synced_at;
-                                if (syncedAt) {
-                                    syncedCount++;
-                                    if (!lastSync || syncedAt > lastSync)
-                                        lastSync = syncedAt;
-                                }
-                            }
-                        }
-                        catch { /* skip */ }
-                        collections.push({ name: repo.name, syncRules, syncedCount, lastSync });
-                    }
-                    // Also list available source definitions
-                    const configMgr = new SourceConfigManager(workspacePath);
-                    const sources = configMgr.getAll().map(s => s.name);
-                    // Check for new-format too
-                    const { readdirSync } = await import('fs');
-                    const sourcesDir = join(workspacePath, '.studiograph', 'sources');
-                    if (existsSync(sourcesDir)) {
-                        for (const file of readdirSync(sourcesDir)) {
-                            if (!file.endsWith('.json'))
-                                continue;
-                            const name = file.replace('.json', '');
-                            if (!sources.includes(name)) {
-                                const def = configMgr.getDefinition(name);
-                                if (def)
-                                    sources.push(name);
-                            }
-                        }
-                    }
-                    return wrapToolResult({
-                        success: true,
-                        collections,
-                        availableSources: sources,
-                        message: collections.length > 0
-                            ? `${collections.length} collection(s) with sync rules`
-                            : 'No collections have sync rules configured.',
-                    });
-                }
-                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',
-                    });
-                }
-            },
-        },
-        // 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(workspacePath).map(c => ({
-                        name: c.name,
-                        url: c.url,
-                        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 (admin only).',
-            parameters: T.Object({
-                name: T.String({ description: 'Source name — must match a built-in source definition (e.g. "linear", "pipedrive", "granola", "asana")' }),
-                connector: T.Optional(T.String({ description: 'Connector name (defaults to source name)' })),
-                force: T.Optional(T.Boolean({ description: 'Overwrite existing source config' })),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    const denied = adminOnly();
-                    if (denied)
-                        return wrapToolResult({ success: false, error: denied });
-                    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(workspacePath);
-                    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),
-                        });
-                    }
-                    // Built-in definition required — don't allow custom configs
-                    const definition = SOURCE_DEFINITIONS[params.name] ?? SOURCE_DEFINITIONS[connectorName];
-                    if (!definition || !definition.entities || Object.keys(definition.entities).length === 0) {
-                        return wrapToolResult({
-                            success: false,
-                            error: `No built-in source definition for "${params.name}". Available sources: ${Object.keys(SOURCE_DEFINITIONS).join(', ')}`,
-                        });
-                    }
-                    // Save as new-format source definition
-                    const savedDef = {
-                        ...definition,
-                        name: params.name,
-                        enabled: true,
-                        added_at: new Date().toISOString(),
-                    };
-                    configMgr.saveDefinition(params.name, savedDef);
-                    const entityTypes = Object.keys(definition.entities);
-                    return wrapToolResult({
-                        success: true,
-                        message: `Source "${params.name}" configured with ${entityTypes.length} entity type(s): ${entityTypes.join(', ')}. Assign it to a collection via sync rules in collection settings.`,
-                        definition: savedDef,
-                    });
-                }
-                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 (admin only).',
-            parameters: T.Object({
-                name: T.String({ description: 'Source name to remove' }),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    const denied = adminOnly();
-                    if (denied)
-                        return wrapToolResult({ success: false, error: denied });
-                    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',
-                    });
-                }
-            },
-        },
-        // ── Connector introspection for sync config building ────────────────────
-        // Inspect a connector's tools, categorized for sync
-        {
-            name: 'sync_inspect_connector',
-            label: 'Inspect Connector for Sync',
-            description: 'Inspect a connector\'s MCP tools to understand what data types are available for sync. Auto-categorizes tools by purpose (list, get, search, create) and detects syncable entity types with their list/get tool pairs. Use this when building a new source config to understand what the connector offers.',
-            parameters: T.Object({
-                connector: T.String({ description: 'Connector name (e.g. "pipedrive", "linear", "granola")' }),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    const reg = getRegistry();
-                    const tools = reg?.connectors.get(params.connector);
-                    if (!tools) {
-                        const available = reg ? [...reg.connectors.keys()] : [];
-                        return wrapToolResult({
-                            success: false,
-                            error: available.length === 0
-                                ? 'No connectors loaded yet. Connectors may still be initializing, or none are configured.'
-                                : `Connector "${params.connector}" not found`,
-                            availableConnectors: available,
-                        });
-                    }
-                    // Categorize tools by purpose
-                    const categories = {
-                        list: [],
-                        get: [],
-                        search: [],
-                        create: [],
-                        update: [],
-                        delete: [],
-                        other: [],
-                    };
-                    for (const tool of tools) {
-                        const n = tool.localName;
-                        if (/(?:^list_|_list$|_list_)/.test(n))
-                            categories.list.push({ name: n, description: tool.description });
-                        else if (/(?:^get_|_get$|^read_|_read$)/.test(n))
-                            categories.get.push({ name: n, description: tool.description });
-                        else if (/(?:^search_|_search$)/.test(n))
-                            categories.search.push({ name: n, description: tool.description });
-                        else if (/(?:^create_|_create$)/.test(n))
-                            categories.create.push({ name: n, description: tool.description });
-                        else if (/(?:^update_|_update$)/.test(n))
-                            categories.update.push({ name: n, description: tool.description });
-                        else if (/(?:^delete_|_delete$|^remove_|_remove$)/.test(n))
-                            categories.delete.push({ name: n, description: tool.description });
-                        else
-                            categories.other.push({ name: n, description: tool.description });
-                    }
-                    // Detect syncable entity types (list + optional get pairs)
-                    const toolNames = new Set(tools.map(t => t.localName));
-                    const detected = [];
-                    for (const tool of categories.list) {
-                        // Extract entity type from tool name
-                        let sourceType = null;
-                        const listMatch = tool.name.match(/^list_(.+?)s?$/);
-                        if (listMatch)
-                            sourceType = listMatch[1];
-                        if (!sourceType) {
-                            const suffixMatch = tool.name.match(/^(.+?)s?_list(?:_|$)/);
-                            if (suffixMatch)
-                                sourceType = suffixMatch[1];
-                        }
-                        if (!sourceType)
-                            continue;
-                        if (detected.some(d => d.source_type === sourceType))
-                            continue;
-                        // Find corresponding get tool
-                        const getVariants = [`get_${sourceType}`, `${sourceType}_get`, `${sourceType}s_get`, `read_${sourceType}`];
-                        const getTool = getVariants.find(g => toolNames.has(g)) ?? null;
-                        detected.push({ source_type: sourceType, list_tool: tool.name, get_tool: getTool });
-                    }
-                    return wrapToolResult({
-                        success: true,
-                        connector: params.connector,
-                        totalTools: tools.length,
-                        categories: Object.fromEntries(Object.entries(categories).filter(([_, v]) => v.length > 0)),
-                        syncableTypes: detected,
-                        hint: detected.length > 0
-                            ? 'Use sync_sample_data to fetch a sample record from any list tool and see available fields for field_map building.'
-                            : 'No list tools detected. This connector may not support sync, or tools may use non-standard naming.',
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                }
-            },
-        },
-        // Fetch sample data from a connector to inspect field shapes
-        {
-            name: 'sync_sample_data',
-            label: 'Fetch Sample Data',
-            description: 'Fetch a sample record from a connector to inspect its field structure. Calls a list tool with limit 1 and returns the field names, types, nesting, and sample values. Use this to auto-build field_map entries for sync source configs.',
-            parameters: T.Object({
-                connector: T.String({ description: 'Connector name (e.g. "pipedrive", "linear")' }),
-                tool: T.String({ description: 'Tool name to call (e.g. "deals_list", "list_issues")' }),
-                arguments: T.Optional(T.Object({}, { additionalProperties: true, description: 'Extra arguments to pass to the tool (limit is auto-set to 1 if the tool accepts it)' })),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    const reg = getRegistry();
-                    const tools = reg?.connectors.get(params.connector);
-                    if (!tools) {
-                        const available = reg ? [...reg.connectors.keys()] : [];
-                        return wrapToolResult({
-                            success: false,
-                            error: available.length === 0
-                                ? 'No connectors loaded yet. Connectors may still be initializing, or none are configured.'
-                                : `Connector "${params.connector}" not found`,
-                            availableConnectors: available,
-                        });
-                    }
-                    const tool = tools.find(t => t.localName === params.tool);
-                    if (!tool) {
-                        return wrapToolResult({
-                            success: false,
-                            error: `Tool "${params.tool}" not found in ${params.connector}`,
-                            availableTools: tools.slice(0, 30).map(t => t.localName),
-                        });
-                    }
-                    // Build arguments — try to limit to 1 record
-                    const args = { ...params.arguments };
-                    const schema = tool.parameters;
-                    const props = schema?.properties || {};
-                    if ('limit' in props && !args.limit)
-                        args.limit = 1;
-                    if ('first' in props && !args.first)
-                        args.first = 1;
-                    if ('per_page' in props && !args.per_page)
-                        args.per_page = 1;
-                    if ('page_size' in props && !args.page_size)
-                        args.page_size = 1;
-                    // Call the tool
-                    const result = await tool.execute(toolCallId, args);
-                    const text = result?.content?.[0]?.text ?? '';
-                    // Parse the response
-                    let data;
-                    try {
-                        data = JSON.parse(text);
-                    }
-                    catch {
-                        // Some tools return double-wrapped content
-                        try {
-                            const outer = JSON.parse(text);
-                            if (outer.content?.[0]?.text) {
-                                data = JSON.parse(outer.content[0].text);
-                            }
-                        }
-                        catch {
-                            return wrapToolResult({
-                                success: true,
-                                rawResponse: text.slice(0, 3000),
-                                note: 'Response is not JSON. Showing raw text for manual inspection.',
-                            });
-                        }
-                    }
-                    // Extract the first record from common response shapes
-                    let record = null;
-                    if (Array.isArray(data)) {
-                        record = data[0];
-                    }
-                    else if (data?.data && Array.isArray(data.data)) {
-                        record = data.data[0];
-                    }
-                    else if (data?.items && Array.isArray(data.items)) {
-                        record = data.items[0];
-                    }
-                    else if (data?.results && Array.isArray(data.results)) {
-                        record = data.results[0];
-                    }
-                    else if (data?.nodes && Array.isArray(data.nodes)) {
-                        record = data.nodes[0];
-                    }
-                    else if (typeof data === 'object' && data !== null && !Array.isArray(data)) {
-                        // Might be a single record response
-                        record = data;
-                    }
-                    if (!record) {
-                        return wrapToolResult({
-                            success: true,
-                            note: 'No records returned. The source may be empty or the tool may need different arguments.',
-                            responseShape: typeof data,
-                            responseKeys: data && typeof data === 'object' ? Object.keys(data) : [],
-                        });
-                    }
-                    // Analyze field structure
-                    const analyzeFields = (obj, prefix = '') => {
-                        const fields = [];
-                        if (!obj || typeof obj !== 'object')
-                            return fields;
-                        for (const [key, value] of Object.entries(obj)) {
-                            const path = prefix ? `${prefix}.${key}` : key;
-                            const type = value === null ? 'null'
-                                : Array.isArray(value) ? `array(${value.length})`
-                                    : typeof value;
-                            // Truncate long strings for display
-                            let sample = value;
-                            if (typeof value === 'string' && value.length > 100) {
-                                sample = value.slice(0, 100) + '...';
-                            }
-                            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                                fields.push({ path, type: 'object', sample: `{${Object.keys(value).join(', ')}}` });
-                                // Recurse one level into objects
-                                fields.push(...analyzeFields(value, path));
-                            }
-                            else if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object') {
-                                fields.push({ path, type: `array(${value.length})`, sample: `[{${Object.keys(value[0]).join(', ')}}]` });
-                            }
-                            else {
-                                fields.push({ path, type, sample });
-                            }
-                        }
-                        return fields;
-                    };
-                    const fields = analyzeFields(record);
-                    // Suggest field_map entries for common entity fields
-                    const topLevelKeys = Object.keys(record);
-                    const suggestions = {};
-                    const nameFields = ['title', 'name', 'subject', 'summary'];
-                    const statusFields = ['status', 'state', 'stage'];
-                    const dateFields = ['created_at', 'createdAt', 'date', 'start_date', 'due_date', 'dueDate'];
-                    const descFields = ['description', 'content', 'body', 'notes', 'note'];
-                    for (const key of topLevelKeys) {
-                        if (nameFields.includes(key))
-                            suggestions[key] = 'name';
-                        else if (statusFields.includes(key))
-                            suggestions[key] = 'status';
-                        else if (dateFields.includes(key))
-                            suggestions[key] = 'date (use date-iso transform)';
-                        else if (descFields.includes(key))
-                            suggestions[key] = 'description (or use as content_from)';
-                    }
-                    return wrapToolResult({
-                        success: true,
-                        connector: params.connector,
-                        tool: params.tool,
-                        fieldCount: fields.length,
-                        fields,
-                        topLevelKeys,
-                        suggestedFieldMap: Object.keys(suggestions).length > 0 ? suggestions : undefined,
-                        hint: 'Use these field paths in field_map when configuring sync_setup_source. Nested fields use dot notation (e.g. "org_id.name": "organization").',
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown 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 collections. Run after sync, enrich, or manual entity edits to update search results.',
-            parameters: T.Object({
-                repo: T.Optional(T.String({ description: 'Reindex a single collection 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. IMPORTANT: Pushing does NOT automatically update a Railway deployment. If the workspace is deployed to Railway, call redeploy_railway after pushing to trigger a fresh deploy with the latest commits.',
-            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