Refactor command arguments to enable AI prompts with JupyterGIS

packages/base/src/commands/processingCommandsFromParams.ts

@@ -0,0 +1,112 @@
+import {
+  IJGISFormSchemaRegistry,
+  ProcessingLogicType,
+  ProcessingType,
+  ProcessingMerge,
+} from '@jupytergis/schema';
+import { JupyterFrontEnd } from '@jupyterlab/application';
+import { CommandRegistry } from '@lumino/commands';
+
+import { processSelectedLayer } from '../processing';
+import { replaceInSql } from '../processing/processingCommands';
+import { JupyterGISTracker } from '../types';
+
+/**
+ * Dynamically registers processing commands from schemas and ProcessingMerge metadata.
+ */
+export function addProcessingCommandsFromParams(options: {
+  app: JupyterFrontEnd;
+  commands: CommandRegistry;
+  tracker: JupyterGISTracker;
+  trans: any;
+  formSchemaRegistry: IJGISFormSchemaRegistry;
+  processingSchemas: Record<string, any>;
+}) {
+  const {
+    app,
+    commands,
+    tracker,
+    trans,
+    formSchemaRegistry,
+    processingSchemas,
+  } = options;
+
+  for (const processingElement of ProcessingMerge) {
+    if (processingElement.type !== ProcessingLogicType.vector) {
+      console.error(
+        `Skipping unsupported processing type: ${processingElement.type}`,
+      );
+      continue;
+    }
+
+    const schema = processingSchemas[processingElement.name];
+    if (!schema) {
+      console.warn(
+        `No schema found for ${processingElement.name}, skipping command`,
+      );
+      continue;
+    }
+
+    const commandId = `${processingElement.name}WithParams`;
+
+    commands.addCommand(commandId, {
+      label: trans.__(`${processingElement.label} from params`),
+      isEnabled: () => true,
+      describedBy: {
+        args: {
+          type: 'object',
+          required: ['filePath', 'params'],
+          properties: {
+            filePath: {
+              type: 'string',
+              description: 'Path to the .jGIS file containing the layer',
+            },
+            params: schema,
+          },
+        },
+      },
+      execute: (async (args: {
+        filePath: string;
+        params: Record<string, any>;
+      }) => {
+        const { filePath, params } = args;
+        const current = tracker.find(w => w.model.filePath === filePath);
+
+        if (!current) {
+          console.warn('No JupyterGIS widget found for', filePath);
+          return;
+        }
+
+        // Build SQL using replaceInSql()
+        const sql = replaceInSql(
+          processingElement.operations.sql,
+          Object.fromEntries(
+            Object.entries(params).map(([k, v]) => [k, String(v)]),
+          ),
+          params.inputLayer ?? '',
+        );
+
+        // Execute using standard processSelectedLayer()
+        await processSelectedLayer(
+          tracker,
+          formSchemaRegistry,
+          processingElement as unknown as ProcessingType,
+          {
+            sqlQueryFn: () => sql,
+            gdalFunction: processingElement.operations.gdalFunction,
+            options: (query: string) => [
+              '-f',
+              'GeoJSON',
+              '-dialect',
+              'SQLITE',
+              '-sql',
+              query,
+              'output.geojson',
+            ],
+          },
+          app,
+        );
+      }) as any,
+    });
+  }
+}

packages/base/src/mainview/mainView.tsx

@@ -540,6 +540,16 @@ export class MainView extends React.Component<IProps, IStates> {
 
   addContextMenu = (): void => {
     this._commands.addCommand(CommandIDs.addAnnotation, {
+      label: 'Add annotation',
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      isEnabled: () => {
+        return !!this._Map;
+      },
       execute: () => {
         if (!this._Map) {
           return;
@@ -557,10 +567,6 @@ export class MainView extends React.Component<IProps, IStates> {
           open: true,
         });
       },
-      label: 'Add annotation',
-      isEnabled: () => {
-        return !!this._Map;
-      },
     });
 
     this._contextMenu.addItem({

packages/base/src/processing/processingCommands.ts

@@ -51,6 +51,12 @@ export function addProcessingCommands(
     if (processingElement.type === ProcessingLogicType.vector) {
       commands.addCommand(processingElement.name, {
         label: trans.__(processingElement.label),
+        describedBy: {
+          args: {
+            type: 'object',
+            properties: {},
+          },
+        },
         isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
         execute: async () => {
           await processSelectedLayer(

python/jupytergis_core/src/jgisplugin/plugins.ts

@@ -161,6 +161,22 @@ const activate = async (
 
   app.commands.addCommand(CommandIDs.createNew, {
     label: args => (args['label'] as string) ?? 'GIS Project',
+    describedBy: {
+      args: {
+        type: 'object',
+        properties: {
+          label: {
+            type: 'string',
+            description: 'The label for the file creation command',
+          },
+          cwd: {
+            type: 'string',
+            description:
+              'The current working directory where the file should be created',
+          },
+        },
+      },
+    },
     caption: 'Create a new JGIS Editor',
     icon: args => logoIcon,
     execute: async args => {

python/jupytergis_qgis/src/plugins.ts

@@ -214,6 +214,18 @@ const activate = async (
   if (installed) {
     app.commands.addCommand(CommandIDs.exportQgis, {
       label: 'Export To QGZ',
+      describedBy: {
+        args: {
+          type: 'object',
+          properties: {
+            filepath: {
+              type: 'string',
+              description:
+                'Optional. Destination filename (with or without .qgz extension) for the exported QGIS project.',
+            },
+          },
+        },
+      },
       isEnabled: () =>
         tracker.currentWidget
           ? tracker.currentWidget.model.sharedModel.editable