@agentlang/agentmanager 0.0.3

package/apps/knowledge/src/generated/prisma-sqlite/models.ts

@@ -0,0 +1,12 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This is a barrel export file for all models and their related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+export type * from './models/KnowledgeEntity'
+export type * from './commonInputTypes'

package/apps/knowledge/src/main.ts

@@ -0,0 +1,48 @@
+import { NestFactory } from '@nestjs/core';
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from '@nestjs/platform-fastify';
+import { Logger } from '@nestjs/common';
+import { ZodValidationPipe } from 'nestjs-zod';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+import helmet from '@fastify/helmet';
+import { AppModule } from './app.module';
+import { ConfigService } from '@nestjs/config';
+
+async function bootstrap() {
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule,
+    new FastifyAdapter({ bodyLimit: 1_048_576 }),
+  );
+
+  await app.register(helmet as Parameters<typeof app.register>[0], {
+    contentSecurityPolicy: false,
+  });
+
+  app.enableCors({ origin: true });
+  app.enableShutdownHooks();
+  app.useGlobalPipes(new ZodValidationPipe());
+
+  const config = app.get(ConfigService);
+  const port = config.get<number>('port', 8080);
+
+  const swaggerConfig = new DocumentBuilder()
+    .setTitle('Knowledge Service')
+    .setVersion('1.0')
+    .addBearerAuth()
+    .build();
+  const document = SwaggerModule.createDocument(app, swaggerConfig);
+  SwaggerModule.setup('docs', app, document);
+
+  await app.listen(port, '0.0.0.0');
+
+  const logger = new Logger('Bootstrap');
+  logger.log(`Knowledge listening on port ${port}`);
+}
+
+bootstrap().catch((err) => {
+  const logger = new Logger('Bootstrap');
+  logger.error(`Failed to start Knowledge: ${err}`);
+  process.exit(1);
+});

package/apps/knowledge/src/modules/auth/auth.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { AuthService } from './auth.service';
+
+@Module({
+  providers: [AuthService],
+  exports: [AuthService],
+})
+export class AuthModule {}

package/apps/knowledge/src/modules/auth/auth.service.ts

@@ -0,0 +1,290 @@
+import {
+  AdminAddUserToGroupCommand,
+  CognitoIdentityProviderClient,
+  InitiateAuthCommand,
+} from '@aws-sdk/client-cognito-identity-provider';
+import {
+  BadRequestException,
+  Injectable,
+  ServiceUnavailableException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { createHmac, randomUUID } from 'node:crypto';
+
+interface CognitoSettings {
+  region: string;
+  userPoolId: string;
+  clientId: string;
+  clientSecret?: string;
+  defaultGroup?: string;
+}
+
+@Injectable()
+export class AuthService {
+  private readonly authEnabled: boolean;
+  private readonly cognitoSettings?: CognitoSettings;
+  private readonly cognitoClient?: CognitoIdentityProviderClient;
+
+  public constructor() {
+    this.authEnabled = process.env.AUTH_ENABLED !== 'false';
+
+    this.cognitoSettings = this.loadCognitoSettings();
+    if (this.authEnabled && this.cognitoSettings) {
+      this.cognitoClient = new CognitoIdentityProviderClient({
+        region: this.cognitoSettings.region,
+      });
+    }
+  }
+
+  public async login(body: Record<string, unknown>) {
+    const username = this.readString(body, ['username', 'email']);
+    const password = this.readString(body, ['password']);
+
+    if (!username || !password) {
+      throw new BadRequestException('username/email and password are required');
+    }
+
+    if (!this.authEnabled) {
+      return this.buildDisabledAuthResponse(username);
+    }
+
+    const cognito = this.ensureCognitoConfig();
+    const authParameters: Record<string, string> = {
+      USERNAME: username,
+      PASSWORD: password,
+    };
+
+    if (cognito.clientSecret) {
+      authParameters.SECRET_HASH = this.buildSecretHash(
+        username,
+        cognito.clientId,
+        cognito.clientSecret,
+      );
+    }
+
+    try {
+      const response = await this.cognitoClient?.send(
+        new InitiateAuthCommand({
+          AuthFlow: 'USER_PASSWORD_AUTH',
+          ClientId: cognito.clientId,
+          AuthParameters: authParameters,
+        }),
+      );
+
+      if (!response?.AuthenticationResult) {
+        throw new UnauthorizedException('Invalid credentials');
+      }
+
+      return this.formatTokenResponse(response.AuthenticationResult, username);
+    } catch (error) {
+      throw new UnauthorizedException('Login failed', {
+        cause: error as Error,
+      });
+    }
+  }
+
+  public async refreshToken(body: Record<string, unknown>) {
+    const refreshToken = this.readString(body, [
+      'refresh_token',
+      'refreshToken',
+    ]);
+    if (!refreshToken) {
+      throw new BadRequestException('refreshToken is required');
+    }
+
+    if (!this.authEnabled) {
+      return this.buildDisabledAuthResponse('local-user', refreshToken);
+    }
+
+    const cognito = this.ensureCognitoConfig();
+    const authParameters: Record<string, string> = {
+      REFRESH_TOKEN: refreshToken,
+    };
+
+    const username = this.readString(body, ['username', 'email']) ?? '';
+    if (cognito.clientSecret && username) {
+      authParameters.SECRET_HASH = this.buildSecretHash(
+        username,
+        cognito.clientId,
+        cognito.clientSecret,
+      );
+    }
+
+    try {
+      const response = await this.cognitoClient?.send(
+        new InitiateAuthCommand({
+          AuthFlow: 'REFRESH_TOKEN_AUTH',
+          ClientId: cognito.clientId,
+          AuthParameters: authParameters,
+        }),
+      );
+
+      if (!response?.AuthenticationResult) {
+        throw new UnauthorizedException('Invalid refresh token');
+      }
+
+      return this.formatTokenResponse(
+        {
+          ...response.AuthenticationResult,
+          RefreshToken: refreshToken,
+        },
+        username || 'cognito-user',
+      );
+    } catch (error) {
+      throw new UnauthorizedException('Refresh token failed', {
+        cause: error as Error,
+      });
+    }
+  }
+
+  public async assignUserToRoleByEmail(body: Record<string, unknown>) {
+    const email = this.readString(body, ['email']);
+    const role =
+      this.readString(body, ['role', 'group']) ??
+      this.cognitoSettings?.defaultGroup;
+
+    if (!email) {
+      throw new BadRequestException('email is required');
+    }
+
+    if (!role) {
+      throw new BadRequestException('role/group is required');
+    }
+
+    if (!this.authEnabled) {
+      return { success: true, email, role, mode: 'auth-disabled' };
+    }
+
+    const cognito = this.ensureCognitoConfig();
+
+    try {
+      await this.cognitoClient?.send(
+        new AdminAddUserToGroupCommand({
+          UserPoolId: cognito.userPoolId,
+          Username: email,
+          GroupName: role,
+        }),
+      );
+
+      return { success: true, email, role };
+    } catch (error) {
+      throw new UnauthorizedException('Role assignment failed', {
+        cause: error as Error,
+      });
+    }
+  }
+
+  private ensureCognitoConfig(): CognitoSettings {
+    if (!this.cognitoSettings) {
+      throw new ServiceUnavailableException(
+        'Cognito is not configured. Set COGNITO_REGION, COGNITO_USER_POOL_ID, COGNITO_CLIENT_ID.',
+      );
+    }
+
+    return this.cognitoSettings;
+  }
+
+  private loadCognitoSettings(): CognitoSettings | undefined {
+    const region = process.env.COGNITO_REGION;
+    const userPoolId = process.env.COGNITO_USER_POOL_ID;
+    const clientId = process.env.COGNITO_CLIENT_ID;
+
+    if (!region || !userPoolId || !clientId) {
+      return undefined;
+    }
+
+    return {
+      region,
+      userPoolId,
+      clientId,
+      clientSecret: process.env.COGNITO_CLIENT_SECRET,
+      defaultGroup: process.env.COGNITO_DEFAULT_GROUP,
+    };
+  }
+
+  private buildSecretHash(
+    username: string,
+    clientId: string,
+    clientSecret: string,
+  ) {
+    return createHmac('sha256', clientSecret)
+      .update(`${username}${clientId}`)
+      .digest('base64');
+  }
+
+  private formatTokenResponse(
+    result: {
+      IdToken?: string;
+      AccessToken?: string;
+      RefreshToken?: string;
+      ExpiresIn?: number;
+      TokenType?: string;
+    },
+    fallbackUsername: string,
+  ) {
+    const payload = this.decodeJwtPayload(result.IdToken);
+
+    return {
+      id_token: result.IdToken,
+      access_token: result.AccessToken,
+      refresh_token: result.RefreshToken,
+      token_type: result.TokenType ?? 'Bearer',
+      expires_in: result.ExpiresIn,
+      userId: typeof payload?.sub === 'string' ? payload.sub : fallbackUsername,
+      sessionId: randomUUID(),
+    };
+  }
+
+  private buildDisabledAuthResponse(
+    username: string,
+    refreshToken = `disabled-${randomUUID()}`,
+  ) {
+    const token = Buffer.from(
+      JSON.stringify({
+        sub: username,
+        mode: 'auth-disabled',
+        iat: Date.now() / 1000,
+      }),
+      'utf8',
+    ).toString('base64url');
+
+    return {
+      id_token: `disabled.${token}.disabled`,
+      access_token: `disabled.${token}.disabled`,
+      refresh_token: refreshToken,
+      token_type: 'Bearer',
+      expires_in: 3600,
+      userId: username,
+      sessionId: randomUUID(),
+    };
+  }
+
+  private decodeJwtPayload(token: string | undefined) {
+    if (!token) {
+      return null;
+    }
+
+    const parts = token.split('.');
+    if (parts.length < 2) {
+      return null;
+    }
+
+    try {
+      const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
+      return JSON.parse(payload) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+  }
+
+  private readString(input: Record<string, unknown>, keys: string[]) {
+    for (const key of keys) {
+      const value = input[key];
+      if (typeof value === 'string' && value.trim() !== '') {
+        return value;
+      }
+    }
+
+    return undefined;
+  }
+}

package/apps/knowledge/src/modules/documents/documents.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { GraphModule } from '../graph/graph.module';
+import { PlatformModule } from '../platform/platform.module';
+import { StorageModule } from '../storage/storage.module';
+import { DocumentsService } from './documents.service';
+
+@Module({
+  imports: [PlatformModule, StorageModule, GraphModule],
+  providers: [DocumentsService],
+  exports: [DocumentsService],
+})
+export class DocumentsModule {}

package/apps/knowledge/src/modules/documents/documents.service.ts

@@ -0,0 +1,179 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+import { GraphService } from '../graph/graph.service';
+import { MetadataStoreService } from '../platform/metadata-store.service';
+import { VectorStoreService } from '../platform/vector-store.service';
+import { StorageService } from '../storage/storage.service';
+import {
+  CreateDocumentInput,
+  ListDocumentsQueryInput,
+  SoftDeleteDocumentInput,
+} from './dto/document.dto';
+
+@Injectable()
+export class DocumentsService {
+  public constructor(
+    private readonly metadataStore: MetadataStoreService,
+    private readonly storageService: StorageService,
+    private readonly vectorStore: VectorStoreService,
+    private readonly graphService: GraphService,
+  ) {}
+
+  public async getById(id: string) {
+    const document = await this.metadataStore.getById('KnowledgeDocument', id);
+    if (!document) {
+      throw new NotFoundException(`KnowledgeDocument/${id} not found`);
+    }
+
+    return document;
+  }
+
+  public async create(payload: CreateDocumentInput) {
+    const now = new Date().toISOString();
+
+    return this.metadataStore.upsert('KnowledgeDocument', {
+      ...payload,
+      id: payload.id ?? randomUUID(),
+      fileType: payload.fileType ?? 'unknown',
+      status: payload.status ?? 'uploaded',
+      currentVersion: 1,
+      isDeleted: false,
+      createdAt: now,
+      updatedAt: now,
+      lastSyncedAt: payload.lastSyncedAt ?? now,
+    });
+  }
+
+  public async remove(id: string) {
+    const deleted = await this.metadataStore.remove('KnowledgeDocument', id);
+    return {
+      success: deleted,
+      id,
+    };
+  }
+
+  public async list(query: ListDocumentsQueryInput) {
+    const page = query.page ?? 1;
+    const pageSize = query.pageSize ?? 20;
+    const offset = (page - 1) * pageSize;
+
+    const filters: Record<string, string> = {};
+    if (query.tenantId) filters.tenantId = query.tenantId;
+    if (query.appId) filters.appId = query.appId;
+    if (query.topicId) filters.topicId = query.topicId;
+    if (query.connectionId) filters.connectionId = query.connectionId;
+
+    const rows = await this.metadataStore.list('KnowledgeDocument', {
+      filters: Object.keys(filters).length > 0 ? filters : undefined,
+      limit: 2000,
+      offset: 0,
+    });
+
+    let filtered = rows;
+    if (!query.includeDeleted) {
+      filtered = filtered.filter((row) => row.isDeleted !== true);
+    }
+
+    if (query.searchTitle) {
+      const expected = query.searchTitle.toLowerCase();
+      filtered = filtered.filter((row) => {
+        const title =
+          typeof row.title === 'string' ? row.title.toLowerCase() : '';
+        return title.includes(expected);
+      });
+    }
+
+    const paged = filtered.slice(offset, offset + pageSize);
+    return {
+      items: paged,
+      total: filtered.length,
+      page,
+      pageSize,
+    };
+  }
+
+  public async softDelete(payload: SoftDeleteDocumentInput) {
+    const document = await this.getById(payload.documentId);
+    const versions = await this.metadataStore.list('DocumentVersion', {
+      filters: { documentId: payload.documentId },
+      limit: 1000,
+      offset: 0,
+    });
+
+    for (const version of versions) {
+      const objectKey =
+        typeof version.objectKey === 'string'
+          ? version.objectKey
+          : typeof version.storageKey === 'string'
+            ? version.storageKey
+            : undefined;
+
+      if (objectKey) {
+        await this.storageService.deleteObject(objectKey);
+      }
+    }
+
+    const [sectionsDeleted, chunksDeleted, nodesDeleted, relationsDeleted] =
+      await Promise.all([
+        this.deleteByDocumentId('KnowledgeSection', payload.documentId),
+        this.deleteByDocumentId('KnowledgeChunk', payload.documentId, {
+          deleteVectors: true,
+        }),
+        this.deleteByDocumentId('KnowledgeNode', payload.documentId),
+        this.deleteByDocumentId('KnowledgeRelation', payload.documentId),
+      ]);
+
+    const topicLinksDeleted = await this.deleteByDocumentId(
+      'TopicDocument',
+      payload.documentId,
+    );
+
+    await this.graphService.deleteDocumentGraph(payload.documentId);
+
+    await this.metadataStore.upsert('KnowledgeDocument', {
+      ...document,
+      isDeleted: true,
+      status: 'failed',
+      updatedBy: payload.deletedBy,
+      deletedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    } as { id: string });
+
+    return {
+      status: 'completed',
+      documentId: payload.documentId,
+      deletedSections: sectionsDeleted,
+      deletedChunks: chunksDeleted,
+      deletedNodes: nodesDeleted,
+      deletedEdges: relationsDeleted,
+      deletedTopicLinks: topicLinksDeleted,
+      deletedFiles: versions.length,
+    };
+  }
+
+  private async deleteByDocumentId(
+    entity: string,
+    documentId: string,
+    options: { deleteVectors?: boolean } = {},
+  ) {
+    const rows = await this.metadataStore.list(entity, {
+      filters: { documentId },
+      limit: 5000,
+      offset: 0,
+    });
+
+    for (const row of rows) {
+      const id = typeof row.id === 'string' ? row.id : undefined;
+      if (!id) {
+        continue;
+      }
+
+      await this.metadataStore.remove(entity, id);
+      if (options.deleteVectors) {
+        await this.vectorStore.delete(entity, id);
+      }
+    }
+
+    return rows.length;
+  }
+}

package/apps/knowledge/src/modules/documents/dto/document.dto.ts

@@ -0,0 +1,68 @@
+import { createZodDto } from 'nestjs-zod';
+import { z } from 'zod';
+
+const FileTypeSchema = z.enum([
+  'pdf',
+  'markdown',
+  'text',
+  'docx',
+  'html',
+  'json',
+  'csv',
+  'xlsx',
+  'unknown',
+]);
+
+const DocumentStatusSchema = z.enum([
+  'uploaded',
+  'processing',
+  'indexed',
+  'failed',
+]);
+
+export const CreateDocumentSchema = z.object({
+  id: z.string().uuid().optional(),
+  tenantId: z.string().min(1),
+  appId: z.string().min(1),
+  connectionId: z.string().min(1),
+  title: z.string().min(1),
+  remotePath: z.string().min(1),
+  fileName: z.string().min(1),
+  fileType: FileTypeSchema.optional(),
+  sizeBytes: z.number().int().min(0),
+  remoteModifiedAt: z.string().optional(),
+  lastSyncedAt: z.string().optional(),
+  createdBy: z.string().optional(),
+  updatedBy: z.string().optional(),
+  status: DocumentStatusSchema.optional(),
+});
+
+export const ListDocumentsQuerySchema = z.object({
+  tenantId: z.string().optional(),
+  appId: z.string().optional(),
+  topicId: z.string().optional(),
+  connectionId: z.string().optional(),
+  includeDeleted: z.coerce.boolean().optional(),
+  searchTitle: z.string().optional(),
+  page: z.coerce.number().int().min(1).optional(),
+  pageSize: z.coerce.number().int().min(1).max(200).optional(),
+});
+
+export const SoftDeleteDocumentSchema = z.object({
+  documentId: z.string().min(1),
+  deletedBy: z.string().optional(),
+});
+
+export class CreateDocumentDto extends createZodDto(CreateDocumentSchema) {}
+
+export class ListDocumentsQueryDto extends createZodDto(
+  ListDocumentsQuerySchema,
+) {}
+
+export class SoftDeleteDocumentDto extends createZodDto(
+  SoftDeleteDocumentSchema,
+) {}
+
+export type CreateDocumentInput = z.infer<typeof CreateDocumentSchema>;
+export type ListDocumentsQueryInput = z.infer<typeof ListDocumentsQuerySchema>;
+export type SoftDeleteDocumentInput = z.infer<typeof SoftDeleteDocumentSchema>;

package/apps/knowledge/src/modules/graph/graph.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { PlatformModule } from '../platform/platform.module';
+import { GraphService } from './graph.service';
+
+@Module({
+  imports: [PlatformModule],
+  providers: [GraphService],
+  exports: [GraphService],
+})
+export class GraphModule {}