@agentlang/agentmanager 0.0.3

package/apps/knowledge/src/modules/oauth-bridge/oauth-bridge.service.ts

@@ -0,0 +1,135 @@
+import { Injectable, ServiceUnavailableException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { AppConfiguration } from '../../config/configuration';
+
+const PROVIDER_MAP: Record<string, string> = {
+  google_drive: 'google-drive',
+  onedrive: 'onedrive',
+  dropbox: 'dropbox',
+};
+
+@Injectable()
+export class OauthBridgeService {
+  public constructor(
+    private readonly configService: ConfigService<AppConfiguration>,
+  ) {}
+
+  public async getAuthorizeUrl(query: Record<string, string>) {
+    const provider = this.toIntegrationProvider(query.provider);
+    const redirectUri = query.redirectUri;
+
+    const response = await this.request('/integmanager.auth/oauthFlow', {
+      method: 'GET',
+      query: {
+        action: 'authorize',
+        provider,
+        redirectUri,
+      },
+    });
+
+    return {
+      authorizationUrl:
+        (response.authorizationUrl as string | undefined) ??
+        (response.url as string | undefined),
+      state: response.state,
+      provider: query.provider,
+    };
+  }
+
+  public async exchange(body: Record<string, unknown>) {
+    const provider = this.toIntegrationProvider(this.asString(body.provider));
+    const code = this.asString(body.code);
+    const state = this.asString(body.state);
+
+    const response = await this.request('/integmanager.auth/oauthFlow', {
+      method: 'POST',
+      body: {
+        action: 'exchange',
+        provider,
+        code,
+        state,
+      },
+    });
+
+    return {
+      accessToken: response.accessToken,
+      refreshToken: response.refreshToken,
+      expiresIn: response.expiresIn,
+      tokenType: response.tokenType ?? 'Bearer',
+    };
+  }
+
+  public async accessToken(query: Record<string, string>) {
+    const provider = this.toIntegrationProvider(query.provider);
+
+    return this.request('/integmanager.auth/oauthToken', {
+      method: 'GET',
+      query: { provider },
+    });
+  }
+
+  private async request(
+    path: string,
+    options: {
+      method: 'GET' | 'POST';
+      query?: Record<string, string | undefined>;
+      body?: Record<string, unknown>;
+    },
+  ) {
+    const baseUrl = this.configService.get<string>(
+      'integrationManagerBaseUrl',
+      {
+        infer: true,
+      },
+    );
+
+    if (!baseUrl) {
+      throw new ServiceUnavailableException(
+        'INTEGRATION_MANAGER_BASE_URL is required for OAuth bridge endpoints',
+      );
+    }
+
+    const url = new URL(path, baseUrl);
+
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+      if (value !== undefined && value !== '') {
+        url.searchParams.set(key, value);
+      }
+    }
+
+    const response = await fetch(url, {
+      method: options.method,
+      headers:
+        options.method === 'POST'
+          ? {
+              'content-type': 'application/json',
+            }
+          : undefined,
+      body:
+        options.method === 'POST'
+          ? JSON.stringify(options.body ?? {})
+          : undefined,
+    });
+
+    if (!response.ok) {
+      const message = await response.text();
+      throw new ServiceUnavailableException(
+        `OAuth bridge request failed: ${response.status} ${message}`,
+      );
+    }
+
+    return (await response.json()) as Record<string, unknown>;
+  }
+
+  private toIntegrationProvider(provider: string | undefined) {
+    if (!provider) {
+      return 'google-drive';
+    }
+
+    return PROVIDER_MAP[provider] ?? provider;
+  }
+
+  private asString(value: unknown) {
+    return typeof value === 'string' ? value : undefined;
+  }
+}

package/apps/knowledge/src/modules/platform/metadata-store.service.ts

@@ -0,0 +1,314 @@
+import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';
+import type { Prisma as PgPrisma } from '../../generated/prisma-postgres/client';
+import { PrismaClient as PostgresPrismaClient } from '../../generated/prisma-postgres/client';
+import type { Prisma as SqlitePrisma } from '../../generated/prisma-sqlite/client';
+import { PrismaClient as SqlitePrismaClient } from '../../generated/prisma-sqlite/client';
+import { AppConfiguration } from '../../config/configuration';
+import { ListEntitiesOptions, StoredEntity } from './platform.types';
+
+@Injectable()
+export class MetadataStoreService implements OnModuleDestroy {
+  private readonly storeType: 'sqlite' | 'postgres';
+  private readonly sqlitePath: string;
+
+  private readonly postgresPrisma: PostgresPrismaClient | null;
+  private readonly sqlitePrisma: SqlitePrismaClient | null;
+
+  public constructor(
+    private readonly configService: ConfigService<AppConfiguration>,
+  ) {
+    const storeType = this.configService.get<'sqlite' | 'postgres'>(
+      'storeType',
+      {
+        infer: true,
+      },
+    );
+
+    this.storeType = storeType === 'postgres' ? 'postgres' : 'sqlite';
+
+    if (this.storeType === 'postgres') {
+      this.sqlitePath = '';
+      const adapter = new PrismaPg({
+        connectionString: this.buildPostgresUrl(),
+      });
+      this.postgresPrisma = new PostgresPrismaClient({ adapter });
+      this.sqlitePrisma = null;
+      return;
+    }
+
+    const sqlitePath = this.configService.get<string>('sqlitePath', {
+      infer: true,
+    });
+    this.sqlitePath = sqlitePath ?? './.knowledge/knowledge.sqlite';
+    mkdirSync(dirname(this.sqlitePath), { recursive: true });
+
+    const adapter = new PrismaBetterSqlite3({
+      url: this.buildSqliteUrl(this.sqlitePath),
+    });
+    this.sqlitePrisma = new SqlitePrismaClient({ adapter });
+    this.postgresPrisma = null;
+  }
+
+  public async onModuleDestroy() {
+    if (this.postgresPrisma) {
+      await this.postgresPrisma.$disconnect();
+    }
+
+    if (this.sqlitePrisma) {
+      await this.sqlitePrisma.$disconnect();
+    }
+  }
+
+  public async health() {
+    if (this.postgresPrisma) {
+      await this.postgresPrisma.knowledgeEntity.count();
+      return { storeType: this.storeType, status: 'ok' };
+    }
+
+    await this.sqlitePrisma?.knowledgeEntity.count();
+    return { storeType: this.storeType, status: 'ok' };
+  }
+
+  public async getById(
+    entity: string,
+    id: string,
+  ): Promise<StoredEntity | null> {
+    if (this.postgresPrisma) {
+      const row = await this.postgresPrisma.knowledgeEntity.findUnique({
+        where: {
+          entity_id: {
+            entity,
+            id,
+          },
+        },
+      });
+
+      return row ? this.deserialize(row.data) : null;
+    }
+
+    const row = await this.sqlitePrisma?.knowledgeEntity.findUnique({
+      where: {
+        entity_id: {
+          entity,
+          id,
+        },
+      },
+    });
+
+    return row ? this.deserialize(row.data) : null;
+  }
+
+  public async list(
+    entity: string,
+    options: ListEntitiesOptions = {},
+  ): Promise<StoredEntity[]> {
+    const where = this.buildWhere(entity, options.filters ?? {});
+    const hasUnknownFilter = Object.keys(options.filters ?? {}).some(
+      (key) => !this.isIndexedFilterKey(key),
+    );
+
+    const rows = this.postgresPrisma
+      ? await this.postgresPrisma.knowledgeEntity.findMany({
+          where,
+          orderBy: { updatedAt: 'desc' },
+          ...(hasUnknownFilter
+            ? {}
+            : {
+                skip: options.offset ?? 0,
+                take: options.limit ?? 500,
+              }),
+        })
+      : await this.sqlitePrisma?.knowledgeEntity.findMany({
+          where,
+          orderBy: { updatedAt: 'desc' },
+          ...(hasUnknownFilter
+            ? {}
+            : {
+                skip: options.offset ?? 0,
+                take: options.limit ?? 500,
+              }),
+        });
+
+    const decoded = (rows ?? []).map((row) => this.deserialize(row.data));
+    const filtered = hasUnknownFilter
+      ? this.filterInMemory(decoded, options.filters ?? {})
+      : decoded;
+
+    if (hasUnknownFilter) {
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? filtered.length;
+      return filtered.slice(offset, offset + limit);
+    }
+
+    return filtered;
+  }
+
+  public async upsert(
+    entity: string,
+    payload: StoredEntity,
+  ): Promise<StoredEntity> {
+    const indexed = this.extractIndexedFields(payload);
+
+    if (this.postgresPrisma) {
+      await this.postgresPrisma.knowledgeEntity.upsert({
+        where: {
+          entity_id: {
+            entity,
+            id: payload.id,
+          },
+        },
+        create: {
+          entity,
+          id: payload.id,
+          topicId: indexed.topicId,
+          connectionId: indexed.connectionId,
+          documentId: indexed.documentId,
+          documentVersionId: indexed.documentVersionId,
+          status: indexed.status,
+          data: payload as unknown as PgPrisma.InputJsonValue,
+        },
+        update: {
+          topicId: indexed.topicId,
+          connectionId: indexed.connectionId,
+          documentId: indexed.documentId,
+          documentVersionId: indexed.documentVersionId,
+          status: indexed.status,
+          data: payload as unknown as PgPrisma.InputJsonValue,
+        },
+      });
+
+      return payload;
+    }
+
+    await this.sqlitePrisma?.knowledgeEntity.upsert({
+      where: {
+        entity_id: {
+          entity,
+          id: payload.id,
+        },
+      },
+      create: {
+        entity,
+        id: payload.id,
+        topicId: indexed.topicId,
+        connectionId: indexed.connectionId,
+        documentId: indexed.documentId,
+        documentVersionId: indexed.documentVersionId,
+        status: indexed.status,
+        data: payload as unknown as SqlitePrisma.InputJsonValue,
+      },
+      update: {
+        topicId: indexed.topicId,
+        connectionId: indexed.connectionId,
+        documentId: indexed.documentId,
+        documentVersionId: indexed.documentVersionId,
+        status: indexed.status,
+        data: payload as unknown as SqlitePrisma.InputJsonValue,
+      },
+    });
+
+    return payload;
+  }
+
+  public async remove(entity: string, id: string): Promise<boolean> {
+    if (this.postgresPrisma) {
+      const deleted = await this.postgresPrisma.knowledgeEntity.deleteMany({
+        where: { entity, id },
+      });
+      return deleted.count > 0;
+    }
+
+    const deleted = await this.sqlitePrisma?.knowledgeEntity.deleteMany({
+      where: { entity, id },
+    });
+
+    return (deleted?.count ?? 0) > 0;
+  }
+
+  private buildWhere(entity: string, filters: Record<string, string>) {
+    return {
+      entity,
+      topicId: filters.topicId,
+      connectionId: filters.connectionId,
+      documentId: filters.documentId,
+      documentVersionId: filters.documentVersionId,
+      status: filters.status,
+    };
+  }
+
+  private filterInMemory(
+    rows: StoredEntity[],
+    filters: Record<string, string>,
+  ) {
+    return rows.filter((row) =>
+      Object.entries(filters).every(([key, expected]) => {
+        const value = row[key];
+
+        if (
+          typeof value === 'string' ||
+          typeof value === 'number' ||
+          typeof value === 'boolean'
+        ) {
+          return String(value) === expected;
+        }
+
+        return false;
+      }),
+    );
+  }
+
+  private isIndexedFilterKey(key: string) {
+    return (
+      key === 'topicId' ||
+      key === 'connectionId' ||
+      key === 'documentId' ||
+      key === 'documentVersionId' ||
+      key === 'status'
+    );
+  }
+
+  private extractIndexedFields(payload: StoredEntity) {
+    return {
+      topicId: this.readOptionalString(payload.topicId),
+      connectionId: this.readOptionalString(payload.connectionId),
+      documentId: this.readOptionalString(payload.documentId),
+      documentVersionId: this.readOptionalString(payload.documentVersionId),
+      status: this.readOptionalString(payload.status),
+    };
+  }
+
+  private deserialize(value: unknown) {
+    return value as StoredEntity;
+  }
+
+  private readOptionalString(value: unknown) {
+    return typeof value === 'string' ? value : null;
+  }
+
+  private buildPostgresUrl() {
+    const explicit = process.env.POSTGRES_URL;
+    if (explicit) {
+      return explicit;
+    }
+
+    const user = process.env.POSTGRES_USER ?? 'postgres';
+    const password = process.env.POSTGRES_PASSWORD ?? '';
+    const host = process.env.POSTGRES_HOST ?? 'localhost';
+    const port = process.env.POSTGRES_PORT ?? '5432';
+    const database = process.env.POSTGRES_DATABASE ?? 'knowledge';
+
+    const auth = password
+      ? `${encodeURIComponent(user)}:${encodeURIComponent(password)}`
+      : encodeURIComponent(user);
+    return `postgresql://${auth}@${host}:${port}/${database}`;
+  }
+
+  private buildSqliteUrl(path: string) {
+    return path.startsWith('file:') ? path : `file:${path}`;
+  }
+}

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

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { MetadataStoreService } from './metadata-store.service';
+import { VectorStoreService } from './vector-store.service';
+
+@Module({
+  providers: [MetadataStoreService, VectorStoreService],
+  exports: [MetadataStoreService, VectorStoreService],
+})
+export class PlatformModule {}

package/apps/knowledge/src/modules/platform/platform.types.ts

@@ -0,0 +1,23 @@
+export interface StoredEntity {
+  id: string;
+  [key: string]: unknown;
+}
+
+export interface ListEntitiesOptions {
+  filters?: Record<string, string>;
+  limit?: number;
+  offset?: number;
+}
+
+export interface VectorSearchResult {
+  id: string;
+  score: number;
+  metadata: Record<string, unknown>;
+}
+
+export interface VectorRecord {
+  id: string;
+  entity: string;
+  embedding: number[];
+  metadata: Record<string, unknown>;
+}

package/apps/knowledge/src/modules/platform/vector-store.service.ts

@@ -0,0 +1,235 @@
+import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { connect, Connection, Table } from '@lancedb/lancedb';
+import { Pool } from 'pg';
+import { AppConfiguration } from '../../config/configuration';
+import { VectorRecord, VectorSearchResult } from './platform.types';
+
+@Injectable()
+export class VectorStoreService implements OnModuleDestroy {
+  private readonly vectorType: 'lancedb' | 'pgvector';
+  private readonly dimension: number;
+  private readonly lanceDbPath: string;
+
+  private pgPool: Pool | null = null;
+  private lanceConnection: Connection | null = null;
+  private lanceTable: Table | null = null;
+  private initialized = false;
+
+  public constructor(
+    private readonly configService: ConfigService<AppConfiguration>,
+  ) {
+    const vector = this.configService.get('vector', { infer: true });
+
+    this.vectorType = vector?.type ?? 'lancedb';
+    this.dimension = vector?.dimension ?? 1536;
+    this.lanceDbPath = vector?.lanceDbPath ?? './.knowledge/lancedb';
+
+    if (this.vectorType === 'pgvector') {
+      this.pgPool = new Pool(
+        process.env.POSTGRES_URL
+          ? { connectionString: process.env.POSTGRES_URL }
+          : {
+              host: process.env.POSTGRES_HOST,
+              port: parseInt(process.env.POSTGRES_PORT ?? '5432', 10),
+              user: process.env.POSTGRES_USER,
+              password: process.env.POSTGRES_PASSWORD,
+              database: process.env.POSTGRES_DATABASE,
+            },
+      );
+    }
+  }
+
+  public async onModuleDestroy() {
+    if (this.pgPool) {
+      await this.pgPool.end();
+    }
+
+    if (this.lanceConnection) {
+      this.lanceConnection.close();
+    }
+  }
+
+  public async health() {
+    await this.ensureInitialized();
+
+    if (this.vectorType === 'pgvector') {
+      await this.pgPool?.query('SELECT 1');
+      return { vectorType: this.vectorType, status: 'ok' };
+    }
+
+    await this.lanceConnection?.tableNames();
+    return { vectorType: this.vectorType, status: 'ok' };
+  }
+
+  public async upsert(record: VectorRecord) {
+    await this.ensureInitialized();
+
+    if (this.vectorType === 'pgvector' && this.pgPool) {
+      await this.pgPool.query(
+        `INSERT INTO knowledge_vectors (entity, id, embedding, metadata)
+         VALUES ($1, $2, $3::vector, $4::jsonb)
+         ON CONFLICT (entity, id)
+         DO UPDATE SET embedding = EXCLUDED.embedding, metadata = EXCLUDED.metadata, updated_at = NOW()`,
+        [
+          record.entity,
+          record.id,
+          this.toPgVector(record.embedding),
+          JSON.stringify(record.metadata),
+        ],
+      );
+      return;
+    }
+
+    const table = await this.getLanceTable();
+    await table.add([
+      {
+        entity: record.entity,
+        id: record.id,
+        embedding: record.embedding,
+        metadata: JSON.stringify(record.metadata),
+      },
+    ]);
+  }
+
+  public async delete(entity: string, id: string) {
+    await this.ensureInitialized();
+
+    if (this.vectorType === 'pgvector' && this.pgPool) {
+      await this.pgPool.query(
+        'DELETE FROM knowledge_vectors WHERE entity = $1 AND id = $2',
+        [entity, id],
+      );
+      return;
+    }
+
+    const table = await this.getLanceTable();
+    await table.delete(
+      `entity = '${this.escapeString(entity)}' AND id = '${this.escapeString(id)}'`,
+    );
+  }
+
+  public async search(
+    embedding: number[],
+    options: { entity?: string; limit?: number } = {},
+  ): Promise<VectorSearchResult[]> {
+    await this.ensureInitialized();
+
+    const limit = options.limit ?? 10;
+
+    if (this.vectorType === 'pgvector' && this.pgPool) {
+      const values: unknown[] = [this.toPgVector(embedding), limit];
+      let query = `SELECT id, metadata, (1 - (embedding <=> $1::vector)) AS score
+                   FROM knowledge_vectors`;
+
+      if (options.entity) {
+        values.push(options.entity);
+        query += ` WHERE entity = $3`;
+      }
+
+      query += ' ORDER BY embedding <=> $1::vector LIMIT $2';
+      const result = await this.pgPool.query<{
+        id: string;
+        metadata: string | Record<string, unknown>;
+        score: number | string;
+      }>(query, values);
+
+      return result.rows.map((row) => ({
+        id: row.id,
+        score: Number(row.score),
+        metadata: this.deserializeMetadata(row.metadata),
+      }));
+    }
+
+    const table = await this.getLanceTable();
+    let query = table.search(embedding).limit(limit);
+
+    if (options.entity) {
+      query = query.where(`entity = '${this.escapeString(options.entity)}'`);
+    }
+
+    const rows = (await query.toArray()) as Array<Record<string, unknown>>;
+
+    return rows.map((row) => ({
+      id: String(row.id),
+      score: Number(row._distance ?? 0),
+      metadata: this.deserializeMetadata(row.metadata),
+    }));
+  }
+
+  private async getLanceTable(): Promise<Table> {
+    await this.ensureInitialized();
+
+    if (this.lanceTable) {
+      return this.lanceTable;
+    }
+
+    throw new Error('LanceDB table is not initialized');
+  }
+
+  private async ensureInitialized() {
+    if (this.initialized) {
+      return;
+    }
+
+    if (this.vectorType === 'pgvector' && this.pgPool) {
+      await this.pgPool.query('CREATE EXTENSION IF NOT EXISTS vector');
+      await this.pgPool.query(
+        `CREATE TABLE IF NOT EXISTS knowledge_vectors (
+          entity TEXT NOT NULL,
+          id TEXT NOT NULL,
+          embedding VECTOR(${this.dimension}) NOT NULL,
+          metadata JSONB NOT NULL,
+          created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          PRIMARY KEY (entity, id)
+        )`,
+      );
+
+      this.initialized = true;
+      return;
+    }
+
+    mkdirSync(dirname(this.lanceDbPath), { recursive: true });
+    this.lanceConnection = await connect(this.lanceDbPath);
+
+    const names = await this.lanceConnection.tableNames();
+    if (names.includes('knowledge_vectors')) {
+      this.lanceTable =
+        await this.lanceConnection.openTable('knowledge_vectors');
+    } else {
+      this.lanceTable = await this.lanceConnection.createTable(
+        'knowledge_vectors',
+        [
+          {
+            entity: 'seed',
+            id: 'seed',
+            embedding: new Array(this.dimension).fill(0),
+            metadata: '{}',
+          },
+        ],
+      );
+      await this.lanceTable.delete("id = 'seed'");
+    }
+
+    this.initialized = true;
+  }
+
+  private toPgVector(values: number[]) {
+    return `[${values.join(',')}]`;
+  }
+
+  private deserializeMetadata(value: unknown) {
+    if (typeof value === 'string') {
+      return JSON.parse(value) as Record<string, unknown>;
+    }
+
+    return (value ?? {}) as Record<string, unknown>;
+  }
+
+  private escapeString(value: string) {
+    return value.replace(/'/g, "''");
+  }
+}