sync-tool

Sync Tool Between Frontend and Backend

You are synchronizing a geospatial analysis tool between the frontend (app/front-end/) and backend (app/back-end/) codebases. The user will provide a tool name or ID, and optionally the direction.

Determine Direction

First, figure out where the tool currently exists:

1. Check app/back-end/app/tool_registry.py for backend registration
2. Check app/front-end/src/tools/index.ts for frontend registration
3. Check app/back-end/app/tools/ for the backend implementation file
4. Check app/front-end/src/tools/ for the frontend implementation file

Based on what exists:

• Tool exists only in backend → Register it in the frontend (stub only — no analyze() implementation unless the user explicitly asks)
• Tool exists only in frontend → Create a full backend implementation and register it
• Tool exists in both → Report that it's already synced, check if the tool IDs match across both sides

---

Direction A: Backend → Frontend (Registration Only)

When a tool exists in the backend but NOT in the frontend, create a frontend stub. This makes the tool visible in the UI and runnable via the backend, without implementing browser-side logic.

Steps

1. Read the backend tool to extract: id, name, description, version, execution_policy, and what options/attributes it accepts in execute().

2. Create frontend tool file at app/front-end/src/tools/<tool-name>-tool.ts:

import { SimpleTool, ToolOptionSchema } from '@/interfaces/simple-tool';
import { FeatureCollection } from '@/interfaces/data-interfaces';
import { AttributeMapping } from '@/interfaces/attribute-mapping';

export class <ToolClass> implements SimpleTool {
  id = '<tool-id>';                    // Must match backend tool.id exactly
  name = '<Tool Name>';
  description = '<description>';
  icon = '<emoji>';
  category = '<visualization|analysis|processing>' as const;
  version = '<version>';
  capabilities = {
    executionPolicy: 'backend_only' as const,  // Backend-only since no frontend implementation
  };

  // Only declare attributeMapping if the backend tool uses attributes
  attributeMapping?: AttributeMapping = { /* match backend attributes */ };

  getOptionSchema(): ToolOptionSchema[] {
    // Mirror the options the backend tool accepts
    return [ /* ... */ ];
  }

  async analyze(
    data: FeatureCollection,
    options: Record<string, unknown>,
    attributes?: AttributeMapping
  ): Promise<FeatureCollection[]> {
    // This tool runs on the backend only
    throw new Error('<Tool Name> requires the backend server. Enable backend mode to use this tool.');
  }
}