studiograph 1.1.3 → 1.2.0-beta.10

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

@@ -0,0 +1,947 @@
+/**
+ * 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, registryRef) {
+    const getRegistry = () => registryRef?.registry ?? null;
+    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',
+                    });
+                }
+            },
+        },
+        // ── 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',
+                    });
+                }
+            },
+        },
+        // ── 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. 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