@agentlang/agentmanager 0.0.3

package/apps/knowledge/src/api/connections.controller.ts

@@ -0,0 +1,99 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Put,
+  Query,
+} from '@nestjs/common';
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+import { MetadataStoreService } from '../modules/platform/metadata-store.service';
+import { randomUUID } from 'node:crypto';
+
+const CreateConnectionSchema = z.object({
+  tenantId: z.string(),
+  appId: z.string(),
+  provider: z.enum(['google_drive', 'onedrive', 'dropbox']),
+  name: z.string(),
+  syncMode: z.enum(['manual', 'automatic']).optional(),
+});
+
+const UpdateConnectionSchema = z.object({
+  name: z.string().optional(),
+  syncMode: z.enum(['manual', 'automatic']).optional(),
+  status: z.enum(['active', 'paused', 'error']).optional(),
+});
+
+class CreateConnectionDto extends createZodDto(CreateConnectionSchema) {}
+class UpdateConnectionDto extends createZodDto(UpdateConnectionSchema) {}
+
+@Controller('api/connections')
+export class ConnectionsController {
+  public constructor(private readonly metadataStore: MetadataStoreService) {}
+
+  @Get()
+  public async list(
+    @Query('tenantId') tenantId?: string,
+    @Query('appId') appId?: string,
+    @Query('status') status?: string,
+  ) {
+    const filters: Record<string, string> = {};
+    if (tenantId) filters.tenantId = tenantId;
+    if (appId) filters.appId = appId;
+    if (status) filters.status = status;
+
+    const items = await this.metadataStore.list('Connection', {
+      filters: Object.keys(filters).length > 0 ? filters : undefined,
+      limit: 100,
+      offset: 0,
+    });
+
+    return { items, total: items.length };
+  }
+
+  @Get(':id')
+  public async getById(@Param('id') id: string) {
+    const connection = await this.metadataStore.getById('Connection', id);
+    return { connection };
+  }
+
+  @Post()
+  public async create(@Body() payload: CreateConnectionDto) {
+    const now = new Date().toISOString();
+    const connection = await this.metadataStore.upsert('Connection', {
+      ...payload,
+      id: randomUUID(),
+      status: 'active',
+      syncMode: payload.syncMode ?? 'manual',
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    return { connection };
+  }
+
+  @Put(':id')
+  public async update(
+    @Param('id') id: string,
+    @Body() payload: UpdateConnectionDto,
+  ) {
+    const current = await this.metadataStore.getById('Connection', id);
+    const connection = await this.metadataStore.upsert('Connection', {
+      ...current,
+      ...payload,
+      id,
+      updatedAt: new Date().toISOString(),
+    });
+
+    return { connection };
+  }
+
+  @Delete(':id')
+  public async remove(@Param('id') id: string) {
+    await this.metadataStore.remove('Connection', id);
+    return { success: true, id };
+  }
+}

package/apps/knowledge/src/api/documents.controller.ts

@@ -0,0 +1,45 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Post,
+  Query,
+} from '@nestjs/common';
+import {
+  CreateDocumentDto,
+  ListDocumentsQueryDto,
+  SoftDeleteDocumentDto,
+} from '../modules/documents/dto/document.dto';
+import { DocumentsService } from '../modules/documents/documents.service';
+
+@Controller('api/documents')
+export class DocumentsController {
+  public constructor(private readonly documentsService: DocumentsService) {}
+
+  @Get()
+  public list(@Query() query: ListDocumentsQueryDto) {
+    return this.documentsService.list(query);
+  }
+
+  @Get(':id')
+  public getById(@Param('id') id: string) {
+    return this.documentsService.getById(id);
+  }
+
+  @Post()
+  public create(@Body() payload: CreateDocumentDto) {
+    return this.documentsService.create(payload);
+  }
+
+  @Post('soft-delete')
+  public softDelete(@Body() payload: SoftDeleteDocumentDto) {
+    return this.documentsService.softDelete(payload);
+  }
+
+  @Delete(':id')
+  public remove(@Param('id') id: string) {
+    return this.documentsService.remove(id);
+  }
+}

package/apps/knowledge/src/api/graph.controller.ts

@@ -0,0 +1,67 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { GraphService } from '../modules/graph/graph.service';
+import { MetadataStoreService } from '../modules/platform/metadata-store.service';
+
+@Controller('api/graph')
+export class GraphController {
+  public constructor(
+    private readonly graphService: GraphService,
+    private readonly metadataStore: MetadataStoreService,
+  ) {}
+
+  @Get('topics/:topicId')
+  public async getTopicGraph(@Param('topicId') topicId: string) {
+    const [nodes, relations] = await Promise.all([
+      this.metadataStore.list('KnowledgeNode', {
+        filters: { topicId },
+        limit: 1000,
+        offset: 0,
+      }),
+      this.metadataStore.list('KnowledgeRelation', {
+        filters: { topicId },
+        limit: 1000,
+        offset: 0,
+      }),
+    ]);
+
+    return {
+      topicId,
+      nodes,
+      edges: relations.map((relation) => ({
+        id: relation.id,
+        source: relation.fromNodeId,
+        target: relation.toNodeId,
+        type: relation.type,
+      })),
+      nodesJson: JSON.stringify(nodes),
+      edgesJson: JSON.stringify(relations),
+    };
+  }
+
+  @Get('documents/:documentId')
+  public async getDocumentGraph(@Param('documentId') documentId: string) {
+    const [nodes, relations] = await Promise.all([
+      this.metadataStore.list('KnowledgeNode', {
+        filters: { documentId },
+        limit: 1000,
+        offset: 0,
+      }),
+      this.metadataStore.list('KnowledgeRelation', {
+        filters: { documentId },
+        limit: 1000,
+        offset: 0,
+      }),
+    ]);
+
+    return {
+      documentId,
+      nodes,
+      edges: relations,
+    };
+  }
+
+  @Get('health')
+  public async health() {
+    return this.graphService.health();
+  }
+}

package/apps/knowledge/src/api/health.controller.ts

@@ -0,0 +1,39 @@
+import { Controller, Get } from '@nestjs/common';
+import { Public } from '@app/auth';
+import { MetadataStoreService } from '../modules/platform/metadata-store.service';
+import { VectorStoreService } from '../modules/platform/vector-store.service';
+import { GraphService } from '../modules/graph/graph.service';
+import { StorageService } from '../modules/storage/storage.service';
+
+@Controller()
+export class HealthController {
+  public constructor(
+    private readonly metadataStore: MetadataStoreService,
+    private readonly vectorStore: VectorStoreService,
+    private readonly graphService: GraphService,
+    private readonly storageService: StorageService,
+  ) {}
+
+  @Public()
+  @Get('health')
+  public async getHealth() {
+    const [metadata, vector, graph, objectStore] = await Promise.all([
+      this.metadataStore.health(),
+      this.vectorStore.health(),
+      this.graphService.health(),
+      this.storageService.health(),
+    ]);
+
+    return {
+      status: 'ok',
+      service: 'knowledge',
+      timestamp: new Date().toISOString(),
+      dependencies: {
+        metadata,
+        vector,
+        graph,
+        objectStore,
+      },
+    };
+  }
+}

package/apps/knowledge/src/api/ingestion.controller.ts

@@ -0,0 +1,45 @@
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
+import {
+  ProcessQueuesDto,
+  QueueListQueryDto,
+  ReIngestDocumentVersionDto,
+  UploadDocumentVersionDto,
+} from '../modules/ingestion/dto/ingestion.dto';
+import { IngestionWorkflowsService } from '../modules/ingestion/ingestion-workflows.service';
+
+@Controller('api/ingestion')
+export class IngestionController {
+  public constructor(
+    private readonly ingestionWorkflowsService: IngestionWorkflowsService,
+  ) {}
+
+  @Post('document-versions')
+  public uploadDocumentVersion(@Body() payload: UploadDocumentVersionDto) {
+    return this.ingestionWorkflowsService.uploadDocumentVersion(payload);
+  }
+
+  @Post('document-versions/reingest')
+  public reIngestDocumentVersion(@Body() payload: ReIngestDocumentVersionDto) {
+    return this.ingestionWorkflowsService.reIngestDocumentVersion(payload);
+  }
+
+  @Post('queues/process')
+  public processQueues(@Body() payload: ProcessQueuesDto) {
+    return this.ingestionWorkflowsService.processQueuesNow(payload.limit);
+  }
+
+  @Post('queues/recover')
+  public recoverQueues() {
+    return this.ingestionWorkflowsService.recoverQueuesAfterRestart();
+  }
+
+  @Get('queues/vector')
+  public listVectorQueue(@Query() query: QueueListQueryDto) {
+    return this.ingestionWorkflowsService.listVectorQueue(query);
+  }
+
+  @Get('queues/graph')
+  public listGraphQueue(@Query() query: QueueListQueryDto) {
+    return this.ingestionWorkflowsService.listGraphQueue(query);
+  }
+}

package/apps/knowledge/src/api/knowledge-query.controller.ts

@@ -0,0 +1,27 @@
+import { Body, Controller, Post } from '@nestjs/common';
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+import { IngestionService } from '../modules/ingestion/ingestion.service';
+
+const KnowledgeQuerySchema = z.object({
+  queryText: z.string().optional(),
+  query: z.string().optional(),
+  question: z.string().optional(),
+  topicId: z.string().optional(),
+  limit: z.number().optional(),
+  embedding: z.array(z.number()).optional(),
+});
+
+class KnowledgeQueryDto extends createZodDto(KnowledgeQuerySchema) {}
+
+@Controller('api/knowledge')
+export class KnowledgeQueryController {
+  public constructor(private readonly ingestionService: IngestionService) {}
+
+  @Post('query')
+  public query(@Body() payload: KnowledgeQueryDto) {
+    return this.ingestionService.query(
+      payload as unknown as Record<string, unknown>,
+    );
+  }
+}

package/apps/knowledge/src/api/oauth.controller.ts

@@ -0,0 +1,38 @@
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
+import { OauthBridgeService } from '../modules/oauth-bridge/oauth-bridge.service';
+
+@Controller('api/oauth')
+export class OauthController {
+  public constructor(private readonly oauthBridgeService: OauthBridgeService) {}
+
+  @Get('authorize-url')
+  public getAuthorizeUrl(
+    @Query('provider') provider: string,
+    @Query('redirectUri') redirectUri: string,
+  ) {
+    return this.oauthBridgeService.getAuthorizeUrl({
+      provider,
+      redirectUri,
+    });
+  }
+
+  @Post('exchange')
+  public exchange(
+    @Body('provider') provider: string,
+    @Body('code') code: string,
+    @Body('state') state: string,
+  ) {
+    return this.oauthBridgeService.exchange({
+      provider,
+      code,
+      state,
+    });
+  }
+
+  @Get('access-token')
+  public accessToken(@Query('provider') provider: string) {
+    return this.oauthBridgeService.accessToken({
+      provider,
+    });
+  }
+}

package/apps/knowledge/src/api/recommendations.controller.ts

@@ -0,0 +1,63 @@
+import { Controller, Get, Param, Query } from '@nestjs/common';
+import { RecommendationsService } from '../modules/recommendations/recommendations.service';
+import { MetadataStoreService } from '../modules/platform/metadata-store.service';
+
+@Controller('api/recommendations')
+export class RecommendationsController {
+  public constructor(
+    private readonly recommendationsService: RecommendationsService,
+    private readonly metadataStore: MetadataStoreService,
+  ) {}
+
+  @Get('agents')
+  public async listAgentRecommendations(
+    @Query('topicId') topicId?: string,
+    @Query('limit') limit?: string,
+  ) {
+    const filters: Record<string, string> = {};
+    if (topicId) filters.topicId = topicId;
+
+    const items = await this.metadataStore.list('AgentRecommendation', {
+      filters: Object.keys(filters).length > 0 ? filters : undefined,
+      limit: limit ? parseInt(limit, 10) : 50,
+      offset: 0,
+    });
+
+    return { items, total: items.length };
+  }
+
+  @Get('agents/:id')
+  public async getAgentRecommendation(@Param('id') id: string) {
+    const recommendation = await this.metadataStore.getById(
+      'AgentRecommendation',
+      id,
+    );
+    return { found: !!recommendation, recommendation };
+  }
+
+  @Get('automation')
+  public async listAutomationOpportunities(
+    @Query('topicId') topicId?: string,
+    @Query('limit') limit?: string,
+  ) {
+    const filters: Record<string, string> = {};
+    if (topicId) filters.topicId = topicId;
+
+    const items = await this.metadataStore.list('AutomationOpportunity', {
+      filters: Object.keys(filters).length > 0 ? filters : undefined,
+      limit: limit ? parseInt(limit, 10) : 50,
+      offset: 0,
+    });
+
+    return { items, total: items.length };
+  }
+
+  @Get('automation/:id')
+  public async getAutomationOpportunity(@Param('id') id: string) {
+    const opportunity = await this.metadataStore.getById(
+      'AutomationOpportunity',
+      id,
+    );
+    return { found: !!opportunity, opportunity };
+  }
+}

package/apps/knowledge/src/api/scheduler.controller.ts

@@ -0,0 +1,32 @@
+import { Controller, Get, Post } from '@nestjs/common';
+import { SchedulerService } from '../modules/sync/scheduler.service';
+
+@Controller('api/scheduler')
+export class SchedulerController {
+  public constructor(private readonly schedulerService: SchedulerService) {}
+
+  @Get('status')
+  public getStatus() {
+    return {
+      running: this.schedulerService.isSchedulerRunning(),
+    };
+  }
+
+  @Post('start')
+  public start() {
+    this.schedulerService.start();
+    return { status: 'started' };
+  }
+
+  @Post('stop')
+  public stop() {
+    this.schedulerService.stop();
+    return { status: 'stopped' };
+  }
+
+  @Post('restart')
+  public restart() {
+    this.schedulerService.restart();
+    return { status: 'restarted' };
+  }
+}

package/apps/knowledge/src/api/topics.controller.ts

@@ -0,0 +1,46 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import {
+  CreateTopicDto,
+  ListTopicsQueryDto,
+  UpdateTopicDto,
+} from '../modules/topics/dto/topic.dto';
+import { TopicsService } from '../modules/topics/topics.service';
+
+@Controller('api/topics')
+export class TopicsController {
+  public constructor(private readonly topicsService: TopicsService) {}
+
+  @Get()
+  public list(@Query() query: ListTopicsQueryDto) {
+    return this.topicsService.list(query);
+  }
+
+  @Get(':id')
+  public getById(@Param('id') id: string) {
+    return this.topicsService.getById(id);
+  }
+
+  @Post()
+  public create(@Body() payload: CreateTopicDto) {
+    return this.topicsService.create(payload);
+  }
+
+  @Patch(':id')
+  public update(@Param('id') id: string, @Body() payload: UpdateTopicDto) {
+    return this.topicsService.update(id, payload);
+  }
+
+  @Delete(':id')
+  public remove(@Param('id') id: string) {
+    return this.topicsService.remove(id);
+  }
+}

package/apps/knowledge/src/app.module.ts

@@ -0,0 +1,68 @@
+import { Module } from '@nestjs/common';
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { ConfigModule } from '@nestjs/config';
+import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
+import { DomainExceptionFilter, LoggingInterceptor } from '@app/common';
+import { AuthModule as SharedAuthModule } from '@app/auth';
+import configuration from './config/configuration';
+import { AuthController } from './api/auth.controller';
+import { ConnectionsController } from './api/connections.controller';
+import { DocumentsController } from './api/documents.controller';
+import { GraphController } from './api/graph.controller';
+import { HealthController } from './api/health.controller';
+import { IngestionController } from './api/ingestion.controller';
+import { KnowledgeQueryController } from './api/knowledge-query.controller';
+import { OauthController } from './api/oauth.controller';
+import { RecommendationsController } from './api/recommendations.controller';
+import { SchedulerController } from './api/scheduler.controller';
+import { TopicsController } from './api/topics.controller';
+import { AuthModule } from './modules/auth/auth.module';
+import { DocumentsModule } from './modules/documents/documents.module';
+import { GraphModule } from './modules/graph/graph.module';
+import { IngestionModule } from './modules/ingestion/ingestion.module';
+import { OauthBridgeModule } from './modules/oauth-bridge/oauth-bridge.module';
+import { PlatformModule } from './modules/platform/platform.module';
+import { RecommendationsModule } from './modules/recommendations/recommendations.module';
+import { StorageModule } from './modules/storage/storage.module';
+import { SyncModule } from './modules/sync/sync.module';
+import { TopicsModule } from './modules/topics/topics.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+    }),
+    ThrottlerModule.forRoot([{ ttl: 60_000, limit: 100 }]),
+    SharedAuthModule,
+    AuthModule,
+    OauthBridgeModule,
+    PlatformModule,
+    IngestionModule,
+    SyncModule,
+    GraphModule,
+    RecommendationsModule,
+    StorageModule,
+    TopicsModule,
+    DocumentsModule,
+  ],
+  controllers: [
+    HealthController,
+    AuthController,
+    OauthController,
+    KnowledgeQueryController,
+    TopicsController,
+    DocumentsController,
+    ConnectionsController,
+    IngestionController,
+    GraphController,
+    RecommendationsController,
+    SchedulerController,
+  ],
+  providers: [
+    { provide: APP_FILTER, useClass: DomainExceptionFilter },
+    { provide: APP_GUARD, useClass: ThrottlerGuard },
+    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
+  ],
+})
+export class AppModule {}