@hed-hog/core 0.0.222 → 0.0.232

package/hedhog/frontend/app/ai_agent/page.tsx.ejs

@@ -0,0 +1,468 @@
+'use client';
+
+import {
+  Page,
+  PageHeader,
+  PaginationFooter,
+  SearchBar,
+} from '@/components/entity-list';
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent } from '@/components/ui/card';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import {
+  Form,
+  FormControl,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '@/components/ui/form';
+import { Input } from '@/components/ui/input';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import { Textarea } from '@/components/ui/textarea';
+import { useDebounce } from '@/hooks/use-debounce';
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { Bot, Pencil, Plus, Trash2 } from 'lucide-react';
+import { useTranslations } from 'next-intl';
+import { useEffect, useState } from 'react';
+import { useForm } from 'react-hook-form';
+import { toast } from 'sonner';
+import { z } from 'zod';
+
+type Agent = {
+  id: number;
+  slug: string;
+  provider: 'openai' | 'gemini';
+  model: string | null;
+  instructions: string | null;
+  external_agent_id: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+type PaginatedResponse<T> = {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+};
+
+type FormValues = {
+  slug: string;
+  provider: 'openai' | 'gemini';
+  model?: string;
+  instructions?: string;
+};
+
+export default function AiAgentPage() {
+  const { request } = useApp();
+  const t = useTranslations('core.AiAgentPage');
+  const formSchema = z.object({
+    slug: z.string().min(2, t('validationSlugMinLength')),
+    provider: z.enum(['openai', 'gemini']),
+    model: z.string().optional(),
+    instructions: z.string().optional(),
+  });
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = useState(10);
+  const [searchQuery, setSearchQuery] = useState('');
+  const debouncedSearch = useDebounce(searchQuery, 400);
+
+  const [isDialogOpen, setIsDialogOpen] = useState(false);
+  const [editingAgent, setEditingAgent] = useState<Agent | null>(null);
+  const [agentToDelete, setAgentToDelete] = useState<Agent | null>(null);
+
+  const form = useForm<FormValues>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      slug: '',
+      provider: 'openai',
+      model: '',
+      instructions: '',
+    },
+  });
+
+  const { data, isLoading, refetch } = useQuery<PaginatedResponse<Agent>>({
+    queryKey: ['ai-agents', page, pageSize, debouncedSearch],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      params.set('page', String(page));
+      params.set('pageSize', String(pageSize));
+      if (debouncedSearch) params.set('search', debouncedSearch);
+
+      const response = await request<PaginatedResponse<Agent>>({
+        url: `/ai/agent?${params.toString()}`,
+        method: 'GET',
+      });
+
+      return response.data;
+    },
+    initialData: {
+      data: [],
+      total: 0,
+      page: 1,
+      pageSize: 10,
+      totalPages: 1,
+    },
+  });
+
+  useEffect(() => {
+    if (editingAgent) {
+      form.reset({
+        slug: editingAgent.slug,
+        provider: editingAgent.provider,
+        model: editingAgent.model || '',
+        instructions: editingAgent.instructions || '',
+      });
+      return;
+    }
+
+    form.reset({
+      slug: '',
+      provider: 'openai',
+      model: '',
+      instructions: '',
+    });
+  }, [editingAgent, form]);
+
+  const handleOpenCreate = () => {
+    setEditingAgent(null);
+    setIsDialogOpen(true);
+  };
+
+  const handleOpenEdit = (agent: Agent) => {
+    setEditingAgent(agent);
+    setIsDialogOpen(true);
+  };
+
+  const onSubmit = async (values: FormValues) => {
+    try {
+      if (editingAgent) {
+        await request({
+          url: `/ai/agent/${editingAgent.id}`,
+          method: 'PATCH',
+          data: {
+            slug: values.slug,
+            provider: values.provider,
+            model: values.model || undefined,
+            instructions: values.instructions || undefined,
+          },
+        });
+        toast.success(t('toastUpdatedSuccess'));
+      } else {
+        await request({
+          url: '/ai/agent',
+          method: 'POST',
+          data: {
+            slug: values.slug,
+            provider: values.provider,
+            model: values.model || undefined,
+            instructions: values.instructions || undefined,
+          },
+        });
+        toast.success(t('toastCreatedSuccess'));
+      }
+
+      setIsDialogOpen(false);
+      setEditingAgent(null);
+      await refetch();
+    } catch (error: any) {
+      const message =
+        error?.response?.data?.message ||
+        error?.response?.data?.error ||
+        error?.message ||
+        t('toastSaveError');
+      toast.error(String(message));
+    }
+  };
+
+  const handleDelete = async () => {
+    if (!agentToDelete) return;
+
+    try {
+      await request({
+        url: '/ai/agent',
+        method: 'DELETE',
+        data: { ids: [agentToDelete.id] },
+      });
+
+      toast.success(t('toastDeletedSuccess'));
+      setAgentToDelete(null);
+      await refetch();
+    } catch (error: any) {
+      const message =
+        error?.response?.data?.message ||
+        error?.response?.data?.error ||
+        error?.message ||
+        t('toastDeleteError');
+      toast.error(String(message));
+    }
+  };
+
+  return (
+    <Page>
+      <PageHeader
+        breadcrumbs={[
+          { label: t('breadcrumbDashboard'), href: '/' },
+          { label: t('breadcrumbManagement'), href: '/core/management' },
+          { label: t('breadcrumbCurrent') },
+        ]}
+        title={t('title')}
+        description={t('description')}
+        actions={[
+          {
+            label: t('newAgent'),
+            onClick: handleOpenCreate,
+            icon: <Plus className="h-4 w-4" />,
+          },
+        ]}
+      />
+
+      <SearchBar
+        searchQuery={searchQuery}
+        onSearchChange={(value) => {
+          setSearchQuery(value);
+          setPage(1);
+        }}
+        onSearch={() => setPage(1)}
+        placeholder={t('searchPlaceholder')}
+      />
+
+      <Card>
+        <CardContent className="p-0">
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>Slug</TableHead>
+                <TableHead>{t('columnProvider')}</TableHead>
+                <TableHead>{t('columnModel')}</TableHead>
+                <TableHead>{t('columnExternalId')}</TableHead>
+                <TableHead className="text-right">
+                  {t('columnActions')}
+                </TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {isLoading ? (
+                <TableRow>
+                  <TableCell colSpan={5}>{t('loading')}</TableCell>
+                </TableRow>
+              ) : data.data.length === 0 ? (
+                <TableRow>
+                  <TableCell colSpan={5}>{t('empty')}</TableCell>
+                </TableRow>
+              ) : (
+                data.data.map((agent) => (
+                  <TableRow key={agent.id}>
+                    <TableCell>{agent.slug}</TableCell>
+                    <TableCell className="uppercase">
+                      {agent.provider}
+                    </TableCell>
+                    <TableCell>{agent.model || '-'}</TableCell>
+                    <TableCell>{agent.external_agent_id || '-'}</TableCell>
+                    <TableCell className="text-right">
+                      <div className="flex items-center justify-end gap-2">
+                        <Button
+                          variant="outline"
+                          size="icon"
+                          onClick={() => handleOpenEdit(agent)}
+                        >
+                          <Pencil className="h-4 w-4" />
+                        </Button>
+                        <Button
+                          variant="destructive"
+                          size="icon"
+                          onClick={() => setAgentToDelete(agent)}
+                        >
+                          <Trash2 className="h-4 w-4" />
+                        </Button>
+                      </div>
+                    </TableCell>
+                  </TableRow>
+                ))
+              )}
+            </TableBody>
+          </Table>
+        </CardContent>
+      </Card>
+
+      <PaginationFooter
+        currentPage={page}
+        pageSize={pageSize}
+        totalItems={data.total}
+        onPageChange={setPage}
+        onPageSizeChange={(value) => {
+          setPageSize(value);
+          setPage(1);
+        }}
+      />
+
+      <Dialog open={isDialogOpen} onOpenChange={setIsDialogOpen}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>
+              {editingAgent ? t('editTitle') : t('createTitle')}
+            </DialogTitle>
+            <DialogDescription>{t('dialogDescription')}</DialogDescription>
+          </DialogHeader>
+
+          <Form {...form}>
+            <form className="space-y-4" onSubmit={form.handleSubmit(onSubmit)}>
+              <FormField
+                control={form.control}
+                name="slug"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('fieldSlug')}</FormLabel>
+                    <FormControl>
+                      <Input
+                        placeholder={t('fieldSlugPlaceholder')}
+                        {...field}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="provider"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('fieldProvider')}</FormLabel>
+                    <FormControl>
+                      <Select
+                        value={field.value}
+                        onValueChange={field.onChange}
+                      >
+                        <SelectTrigger>
+                          <SelectValue
+                            placeholder={t('fieldProviderPlaceholder')}
+                          />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="openai">
+                            {t('providerOpenai')}
+                          </SelectItem>
+                          <SelectItem value="gemini">
+                            {t('providerGemini')}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="model"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('fieldModel')}</FormLabel>
+                    <FormControl>
+                      <Input
+                        placeholder={t('fieldModelPlaceholder')}
+                        {...field}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="instructions"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t('fieldInstructions')}</FormLabel>
+                    <FormControl>
+                      <Textarea
+                        placeholder={t('fieldInstructionsPlaceholder')}
+                        rows={4}
+                        {...field}
+                      />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <DialogFooter>
+                <Button
+                  type="button"
+                  variant="outline"
+                  onClick={() => setIsDialogOpen(false)}
+                >
+                  {t('cancel')}
+                </Button>
+                <Button type="submit">
+                  <Bot className="h-4 w-4 mr-2" />
+                  {editingAgent ? t('saveChanges') : t('createAgent')}
+                </Button>
+              </DialogFooter>
+            </form>
+          </Form>
+        </DialogContent>
+      </Dialog>
+
+      <AlertDialog
+        open={Boolean(agentToDelete)}
+        onOpenChange={(open) => {
+          if (!open) setAgentToDelete(null);
+        }}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>{t('deleteTitle')}</AlertDialogTitle>
+            <AlertDialogDescription>
+              {t('deleteDescription')}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>{t('cancel')}</AlertDialogCancel>
+            <AlertDialogAction onClick={handleDelete}>
+              {t('delete')}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </Page>
+  );
+}

package/hedhog/table/ai_agent.yaml

@@ -0,0 +1,24 @@
+columns:
+  - type: pk
+  - type: slug
+  - name: provider
+    type: enum
+    enum:
+      - openai
+      - gemini
+    default: openai
+  - name: model
+    isNullable: true
+    length: 127
+  - name: instructions
+    type: text
+    isNullable: true
+  - name: external_agent_id
+    isNullable: true
+    length: 127
+  - type: created_at
+  - type: updated_at
+indices:
+  - columns:
+      - slug
+    isUnique: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/core",
-  "version": "0.0.222",
+  "version": "0.0.232",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -29,12 +29,12 @@
     "sharp": "^0.34.2",
     "speakeasy": "^2.0.0",
     "uuid": "^11.1.0",
-    "@hed-hog/api-mail": "0.0.7",
-    "@hed-hog/api-types": "0.0.1",
     "@hed-hog/api": "0.0.3",
-    "@hed-hog/api-locale": "0.0.11",
     "@hed-hog/api-prisma": "0.0.4",
-    "@hed-hog/api-pagination": "0.0.5"
+    "@hed-hog/api-types": "0.0.1",
+    "@hed-hog/api-locale": "0.0.11",
+    "@hed-hog/api-pagination": "0.0.5",
+    "@hed-hog/api-mail": "0.0.7"
   },
   "exports": {
     ".": {

package/src/ai/ai.controller.ts

@@ -0,0 +1,61 @@
+import { Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import { Body, Controller, Delete, Get, Inject, Param, ParseIntPipe, Patch, Post, forwardRef } from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { AiService } from './ai.service';
+import { ChatAgentDTO } from './dto/chat-agent.dto';
+import { ChatDTO } from './dto/chat.dto';
+import { CreateAgentDTO } from './dto/create-agent.dto';
+import { UpdateAgentDTO } from './dto/update-agent.dto';
+
+@Role()
+@Controller('ai')
+export class AiController {
+  constructor(
+    @Inject(forwardRef(() => AiService))
+    private readonly aiService: AiService,
+  ) {}
+
+  @Post('chat')
+  async chat(@Body() data: ChatDTO) {
+    return this.aiService.chat(data);
+  }
+
+  @Post('agent')
+  async createAgent(@Body() data: CreateAgentDTO) {
+    return this.aiService.createAgent(data);
+  }
+
+  @Get('agent')
+  async listAgents(@Pagination() paginationParams) {
+    return this.aiService.listAgents(paginationParams);
+  }
+
+  @Get('agent/id/:agentId')
+  async getAgentById(@Param('agentId', ParseIntPipe) agentId: number) {
+    return this.aiService.getAgentById(agentId);
+  }
+
+  @Get('agent/:slug')
+  async getAgent(@Param('slug') slug: string) {
+    return this.aiService.getAgentBySlug(slug);
+  }
+
+  @Patch('agent/:agentId')
+  async updateAgent(
+    @Param('agentId', ParseIntPipe) agentId: number,
+    @Body() data: UpdateAgentDTO,
+  ) {
+    return this.aiService.updateAgent(agentId, data);
+  }
+
+  @Delete('agent')
+  async deleteAgents(@Body() data: DeleteDTO) {
+    return this.aiService.deleteAgents(data);
+  }
+
+  @Post('agent/:slug/chat')
+  async chatWithAgent(@Param('slug') slug: string, @Body() data: ChatAgentDTO) {
+    return this.aiService.chatWithAgent(slug, data);
+  }
+}

package/src/ai/ai.module.ts

@@ -0,0 +1,13 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { SettingModule } from '../setting/setting.module';
+import { AiController } from './ai.controller';
+import { AiService } from './ai.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule), forwardRef(() => SettingModule)],
+  controllers: [AiController],
+  providers: [AiService],
+  exports: [AiService],
+})
+export class AiModule {}