clhq-postgres-module 1.1.0-alpha.106 → 1.1.0-alpha.107

package/dist/repositories/ai-embedding.repository.d.ts

@@ -0,0 +1,38 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { AiEmbedding, EmbeddingEntityType, EmbeddingType } from '../entities/ai-embedding.entity';
+export declare class AiEmbeddingRepository extends BaseRepository<AiEmbedding> {
+    private readonly aiEmbeddingRepository;
+    constructor(aiEmbeddingRepository: Repository<AiEmbedding>);
+    findByEntity(entityType: EmbeddingEntityType, entityId: string): Promise<AiEmbedding | null>;
+    findByEntityType(entityType: EmbeddingEntityType, userId?: string): Promise<AiEmbedding[]>;
+    findByUserId(userId: string): Promise<AiEmbedding[]>;
+    findByWorkspaceId(workspaceId: string): Promise<AiEmbedding[]>;
+    upsertEmbedding(data: {
+        entityType: EmbeddingEntityType;
+        entityId: string;
+        userId?: string;
+        workspaceId?: string;
+        embeddingType?: EmbeddingType;
+        embedding: number[];
+        sourceText?: string;
+        modelId: string;
+        modelVersion?: string;
+        metadata?: AiEmbedding['metadata'];
+    }): Promise<AiEmbedding>;
+    deleteByEntity(entityType: EmbeddingEntityType, entityId: string): Promise<boolean>;
+    findSimilar(embedding: number[], entityType: EmbeddingEntityType, userId?: string, limit?: number, excludeEntityId?: string): Promise<Array<AiEmbedding & {
+        similarity: number;
+    }>>;
+    batchFindSimilar(queries: Array<{
+        embedding: number[];
+        entityType: EmbeddingEntityType;
+        userId?: string;
+        limit?: number;
+    }>): Promise<Array<Array<AiEmbedding & {
+        similarity: number;
+    }>>>;
+    getCountsByEntityType(userId?: string): Promise<Record<string, number>>;
+    findByModelVersion(modelId: string, modelVersion?: string): Promise<AiEmbedding[]>;
+    findOutdatedEmbeddings(modelId: string, currentVersion: string, limit?: number): Promise<AiEmbedding[]>;
+}

package/dist/repositories/ai-embedding.repository.js

@@ -0,0 +1,146 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiEmbeddingRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const ai_embedding_entity_1 = require("../entities/ai-embedding.entity");
+let AiEmbeddingRepository = class AiEmbeddingRepository extends base_repository_1.BaseRepository {
+    constructor(aiEmbeddingRepository) {
+        super(aiEmbeddingRepository);
+        this.aiEmbeddingRepository = aiEmbeddingRepository;
+    }
+    async findByEntity(entityType, entityId) {
+        return this.aiEmbeddingRepository.findOne({
+            where: { entityType, entityId },
+        });
+    }
+    async findByEntityType(entityType, userId) {
+        const where = { entityType };
+        if (userId) {
+            where.userId = userId;
+        }
+        return this.aiEmbeddingRepository.find({
+            where,
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByUserId(userId) {
+        return this.aiEmbeddingRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.aiEmbeddingRepository.find({
+            where: { workspaceId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async upsertEmbedding(data) {
+        const existing = await this.findByEntity(data.entityType, data.entityId);
+        if (existing) {
+            await this.aiEmbeddingRepository.update(existing.id, {
+                embedding: data.embedding,
+                embeddingType: data.embeddingType || existing.embeddingType,
+                dimension: data.embedding.length,
+                sourceText: data.sourceText,
+                modelId: data.modelId,
+                modelVersion: data.modelVersion,
+                metadata: data.metadata,
+            });
+            return (await this.findById(existing.id));
+        }
+        return this.create({
+            ...data,
+            dimension: data.embedding.length,
+        });
+    }
+    async deleteByEntity(entityType, entityId) {
+        const result = await this.aiEmbeddingRepository.delete({
+            entityType,
+            entityId,
+        });
+        return (result.affected ?? 0) > 0;
+    }
+    async findSimilar(embedding, entityType, userId, limit = 20, excludeEntityId) {
+        const embeddingStr = JSON.stringify(embedding);
+        const dimension = embedding.length;
+        let query = this.aiEmbeddingRepository
+            .createQueryBuilder('ae')
+            .select('ae.*')
+            .addSelect(`1 - (ae.embedding::vector(${dimension}) <=> '${embeddingStr}'::vector(${dimension}))`, 'similarity')
+            .where('ae.entity_type = :entityType', { entityType })
+            .andWhere('ae.dimension = :dimension', { dimension });
+        if (userId) {
+            query = query.andWhere('ae.user_id = :userId', { userId });
+        }
+        if (excludeEntityId) {
+            query = query.andWhere('ae.entity_id != :excludeEntityId', {
+                excludeEntityId,
+            });
+        }
+        const results = await query
+            .orderBy('similarity', 'DESC')
+            .limit(limit)
+            .getRawMany();
+        return results;
+    }
+    async batchFindSimilar(queries) {
+        const results = await Promise.all(queries.map((query) => this.findSimilar(query.embedding, query.entityType, query.userId, query.limit || 10)));
+        return results;
+    }
+    async getCountsByEntityType(userId) {
+        const queryBuilder = this.aiEmbeddingRepository
+            .createQueryBuilder('ae')
+            .select('ae.entity_type', 'entityType')
+            .addSelect('COUNT(*)', 'count')
+            .groupBy('ae.entity_type');
+        if (userId) {
+            queryBuilder.where('ae.user_id = :userId', { userId });
+        }
+        const results = await queryBuilder.getRawMany();
+        return results.reduce((acc, row) => {
+            acc[row.entityType] = parseInt(row.count, 10);
+            return acc;
+        }, {});
+    }
+    async findByModelVersion(modelId, modelVersion) {
+        const where = { modelId };
+        if (modelVersion) {
+            where.modelVersion = modelVersion;
+        }
+        return this.aiEmbeddingRepository.find({
+            where,
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findOutdatedEmbeddings(modelId, currentVersion, limit = 100) {
+        return this.aiEmbeddingRepository
+            .createQueryBuilder('ae')
+            .where('ae.model_id = :modelId', { modelId })
+            .andWhere('(ae.model_version IS NULL OR ae.model_version != :currentVersion)', { currentVersion })
+            .orderBy('ae.created_at', 'ASC')
+            .limit(limit)
+            .getMany();
+    }
+};
+exports.AiEmbeddingRepository = AiEmbeddingRepository;
+exports.AiEmbeddingRepository = AiEmbeddingRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(ai_embedding_entity_1.AiEmbedding)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], AiEmbeddingRepository);

package/dist/repositories/asset-metadata.repository.d.ts

@@ -0,0 +1,39 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { AssetMetadata, AssetMetadataStatus } from '../entities/asset-metadata.entity';
+export declare class AssetMetadataRepository extends BaseRepository<AssetMetadata> {
+    private readonly assetMetadataRepository;
+    constructor(assetMetadataRepository: Repository<AssetMetadata>);
+    findByAssetId(assetId: string): Promise<AssetMetadata | null>;
+    findByUserId(userId: string): Promise<AssetMetadata[]>;
+    findByWorkspaceId(workspaceId: string): Promise<AssetMetadata[]>;
+    findByStatus(status: AssetMetadataStatus): Promise<AssetMetadata[]>;
+    findPendingForProcessing(limit?: number): Promise<AssetMetadata[]>;
+    updateStatus(id: string, status: AssetMetadataStatus, error?: string): Promise<AssetMetadata | null>;
+    updateEmbedding(id: string, embedding: number[], model: string, version?: string): Promise<AssetMetadata | null>;
+    updateContent(id: string, content: AssetMetadata['content']): Promise<AssetMetadata | null>;
+    updateTechnical(id: string, technical: AssetMetadata['technical']): Promise<AssetMetadata | null>;
+    findSimilarByEmbedding(embedding: number[], userId: string, limit?: number, excludeAssetId?: string, minSimilarity?: number): Promise<Array<AssetMetadata & {
+        similarity: number;
+    }>>;
+    findSimilarByEmbeddingOptimized(embedding: number[], userId: string, limit?: number, minSimilarity?: number): Promise<Array<{
+        assetId: string;
+        similarity: number;
+        category: string;
+        tags: string[];
+        description: string;
+        usageCount: number;
+        lastUsedAt: Date;
+    }>>;
+    findByTags(userId: string, tags: string[]): Promise<AssetMetadata[]>;
+    searchByKeywords(userId: string, searchTerm: string): Promise<AssetMetadata[]>;
+    incrementUsageCount(assetId: string, projectId?: string): Promise<void>;
+    findWithoutEmbeddings(limit?: number): Promise<AssetMetadata[]>;
+    getStatsForUser(userId: string): Promise<{
+        total: number;
+        pending: number;
+        completed: number;
+        failed: number;
+        withEmbeddings: number;
+    }>;
+}

package/dist/repositories/asset-metadata.repository.js

@@ -0,0 +1,195 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetMetadataRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const asset_metadata_entity_1 = require("../entities/asset-metadata.entity");
+let AssetMetadataRepository = class AssetMetadataRepository extends base_repository_1.BaseRepository {
+    constructor(assetMetadataRepository) {
+        super(assetMetadataRepository);
+        this.assetMetadataRepository = assetMetadataRepository;
+    }
+    async findByAssetId(assetId) {
+        return this.assetMetadataRepository.findOne({
+            where: { assetId },
+        });
+    }
+    async findByUserId(userId) {
+        return this.assetMetadataRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.assetMetadataRepository.find({
+            where: { workspaceId },
+            order: { createdAt: 'DESC' },
+        });
+    }
+    async findByStatus(status) {
+        return this.assetMetadataRepository.find({
+            where: { status },
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findPendingForProcessing(limit = 50) {
+        return this.assetMetadataRepository.find({
+            where: { status: asset_metadata_entity_1.AssetMetadataStatus.PENDING },
+            order: { createdAt: 'ASC' },
+            take: limit,
+        });
+    }
+    async updateStatus(id, status, error) {
+        const updateData = { status };
+        if (error) {
+            updateData.processingError = error;
+        }
+        if (status === asset_metadata_entity_1.AssetMetadataStatus.COMPLETED) {
+            updateData.aiProcessedAt = new Date();
+        }
+        await this.assetMetadataRepository.update(id, updateData);
+        return this.findById(id);
+    }
+    async updateEmbedding(id, embedding, model, version) {
+        await this.assetMetadataRepository.update(id, {
+            contentEmbedding: embedding,
+            embeddingModel: model,
+            embeddingVersion: version,
+            embeddingGeneratedAt: new Date(),
+        });
+        return this.findById(id);
+    }
+    async updateContent(id, content) {
+        await this.assetMetadataRepository.update(id, {
+            content,
+            aiProcessedAt: new Date(),
+        });
+        return this.findById(id);
+    }
+    async updateTechnical(id, technical) {
+        await this.assetMetadataRepository.update(id, { technical });
+        return this.findById(id);
+    }
+    async findSimilarByEmbedding(embedding, userId, limit = 20, excludeAssetId, minSimilarity = 0.0) {
+        const embeddingStr = `[${embedding.join(',')}]`;
+        let query = this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .select('am.*')
+            .addSelect(`1 - (COALESCE(am.content_embedding_vec, am.content_embedding::vector(1536)) <=> '${embeddingStr}'::vector(1536))`, 'similarity')
+            .where('am.user_id = :userId', { userId })
+            .andWhere('(am.content_embedding_vec IS NOT NULL OR am.content_embedding IS NOT NULL)');
+        if (excludeAssetId) {
+            query = query.andWhere('am.asset_id != :excludeAssetId', { excludeAssetId });
+        }
+        if (minSimilarity > 0) {
+            query = query.andWhere(`1 - (COALESCE(am.content_embedding_vec, am.content_embedding::vector(1536)) <=> '${embeddingStr}'::vector(1536)) >= :minSimilarity`, { minSimilarity });
+        }
+        const results = await query
+            .orderBy(`COALESCE(am.content_embedding_vec, am.content_embedding::vector(1536)) <=> '${embeddingStr}'::vector(1536)`, 'ASC')
+            .limit(limit)
+            .getRawMany();
+        return results;
+    }
+    async findSimilarByEmbeddingOptimized(embedding, userId, limit = 20, minSimilarity = 0.5) {
+        const embeddingStr = `[${embedding.join(',')}]`;
+        const results = await this.assetMetadataRepository.query(`SELECT * FROM search_similar_assets_optimized($1::vector(1536), $2, $3, $4)`, [embeddingStr, userId, limit, minSimilarity]);
+        return results.map((r) => ({
+            assetId: r.asset_id,
+            similarity: r.similarity,
+            category: r.category,
+            tags: r.tags,
+            description: r.description,
+            usageCount: r.usage_count,
+            lastUsedAt: r.last_used_at,
+        }));
+    }
+    async findByTags(userId, tags) {
+        return this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .where('am.user_id = :userId', { userId })
+            .andWhere('am.tags && :tags', { tags })
+            .orderBy('am.created_at', 'DESC')
+            .getMany();
+    }
+    async searchByKeywords(userId, searchTerm) {
+        return this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .where('am.user_id = :userId', { userId })
+            .andWhere(`(
+          am.description ILIKE :term
+          OR am.category ILIKE :term
+          OR :term = ANY(am.tags)
+          OR am.content->>'transcription' ILIKE :term
+          OR am.content->'keywords' ? :exactTerm
+        )`, { term: `%${searchTerm}%`, exactTerm: searchTerm })
+            .orderBy('am.created_at', 'DESC')
+            .getMany();
+    }
+    async incrementUsageCount(assetId, projectId) {
+        const metadata = await this.findByAssetId(assetId);
+        if (!metadata)
+            return;
+        const projectsUsedIn = metadata.projectsUsedIn || [];
+        if (projectId && !projectsUsedIn.includes(projectId)) {
+            projectsUsedIn.push(projectId);
+        }
+        await this.assetMetadataRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            usageCount: () => 'usage_count + 1',
+            lastUsedAt: new Date(),
+            projectsUsedIn,
+        })
+            .where('asset_id = :assetId', { assetId })
+            .execute();
+    }
+    async findWithoutEmbeddings(limit = 100) {
+        return this.assetMetadataRepository.find({
+            where: {
+                contentEmbedding: null,
+                status: asset_metadata_entity_1.AssetMetadataStatus.COMPLETED,
+            },
+            order: { createdAt: 'ASC' },
+            take: limit,
+        });
+    }
+    async getStatsForUser(userId) {
+        const stats = await this.assetMetadataRepository
+            .createQueryBuilder('am')
+            .select('COUNT(*)', 'total')
+            .addSelect(`COUNT(*) FILTER (WHERE am.status = 'pending')`, 'pending')
+            .addSelect(`COUNT(*) FILTER (WHERE am.status = 'completed')`, 'completed')
+            .addSelect(`COUNT(*) FILTER (WHERE am.status = 'failed')`, 'failed')
+            .addSelect(`COUNT(*) FILTER (WHERE am.content_embedding IS NOT NULL)`, 'withEmbeddings')
+            .where('am.user_id = :userId', { userId })
+            .getRawOne();
+        return {
+            total: parseInt(stats.total, 10),
+            pending: parseInt(stats.pending, 10),
+            completed: parseInt(stats.completed, 10),
+            failed: parseInt(stats.failed, 10),
+            withEmbeddings: parseInt(stats.withEmbeddings, 10),
+        };
+    }
+};
+exports.AssetMetadataRepository = AssetMetadataRepository;
+exports.AssetMetadataRepository = AssetMetadataRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(asset_metadata_entity_1.AssetMetadata)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], AssetMetadataRepository);

package/dist/repositories/index.d.ts

@@ -24,3 +24,8 @@ export { VideoTranscodeRepository } from './video-transcode.repository';
 export { VideoRenderRepository } from './video-render.repository';
 export { VideoFilmstripRepository } from './video-filmstrip.repository';
 export { AudioWaveformRepository } from './audio-waveform.repository';
+export { AssetMetadataRepository } from './asset-metadata.repository';
+export { ProjectMetadataRepository } from './project-metadata.repository';
+export { UserContextRepository } from './user-context.repository';
+export { AiEmbeddingRepository } from './ai-embedding.repository';
+export { MetadataActivityLogRepository } from './metadata-activity-log.repository';

package/dist/repositories/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AudioWaveformRepository = exports.VideoFilmstripRepository = exports.VideoRenderRepository = exports.VideoTranscodeRepository = exports.EffectRepository = exports.AssetRepository = exports.AiUsageRepository = exports.ReferralEventRepository = exports.RewardRuleRepository = exports.CreditTransactionRepository = exports.StripeWebhookRepository = exports.PaymentTransactionRepository = exports.SubscriptionUsageRepository = exports.UserSubscriptionRepository = exports.PlanRepository = exports.SubscriptionPlanRepository = exports.CommentRepository = exports.EditorProjectRepository = exports.InviteRepository = exports.WorkspaceMemberRepository = exports.WorkspaceRepository = exports.AuthSessionRepository = exports.UserOnboardingRepository = exports.UserProfileRepository = exports.UserRepository = exports.BaseRepository = void 0;
+exports.MetadataActivityLogRepository = exports.AiEmbeddingRepository = exports.UserContextRepository = exports.ProjectMetadataRepository = exports.AssetMetadataRepository = exports.AudioWaveformRepository = exports.VideoFilmstripRepository = exports.VideoRenderRepository = exports.VideoTranscodeRepository = exports.EffectRepository = exports.AssetRepository = exports.AiUsageRepository = exports.ReferralEventRepository = exports.RewardRuleRepository = exports.CreditTransactionRepository = exports.StripeWebhookRepository = exports.PaymentTransactionRepository = exports.SubscriptionUsageRepository = exports.UserSubscriptionRepository = exports.PlanRepository = exports.SubscriptionPlanRepository = exports.CommentRepository = exports.EditorProjectRepository = exports.InviteRepository = exports.WorkspaceMemberRepository = exports.WorkspaceRepository = exports.AuthSessionRepository = exports.UserOnboardingRepository = exports.UserProfileRepository = exports.UserRepository = exports.BaseRepository = void 0;
 var base_repository_1 = require("./base.repository");
 Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repository_1.BaseRepository; } });
 var user_repository_1 = require("./user.repository");
@@ -53,3 +53,13 @@ var video_filmstrip_repository_1 = require("./video-filmstrip.repository");
 Object.defineProperty(exports, "VideoFilmstripRepository", { enumerable: true, get: function () { return video_filmstrip_repository_1.VideoFilmstripRepository; } });
 var audio_waveform_repository_1 = require("./audio-waveform.repository");
 Object.defineProperty(exports, "AudioWaveformRepository", { enumerable: true, get: function () { return audio_waveform_repository_1.AudioWaveformRepository; } });
+var asset_metadata_repository_1 = require("./asset-metadata.repository");
+Object.defineProperty(exports, "AssetMetadataRepository", { enumerable: true, get: function () { return asset_metadata_repository_1.AssetMetadataRepository; } });
+var project_metadata_repository_1 = require("./project-metadata.repository");
+Object.defineProperty(exports, "ProjectMetadataRepository", { enumerable: true, get: function () { return project_metadata_repository_1.ProjectMetadataRepository; } });
+var user_context_repository_1 = require("./user-context.repository");
+Object.defineProperty(exports, "UserContextRepository", { enumerable: true, get: function () { return user_context_repository_1.UserContextRepository; } });
+var ai_embedding_repository_1 = require("./ai-embedding.repository");
+Object.defineProperty(exports, "AiEmbeddingRepository", { enumerable: true, get: function () { return ai_embedding_repository_1.AiEmbeddingRepository; } });
+var metadata_activity_log_repository_1 = require("./metadata-activity-log.repository");
+Object.defineProperty(exports, "MetadataActivityLogRepository", { enumerable: true, get: function () { return metadata_activity_log_repository_1.MetadataActivityLogRepository; } });

package/dist/repositories/metadata-activity-log.repository.d.ts

@@ -0,0 +1,41 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { MetadataActivityLog, MetadataActivityAction, MetadataActivitySource } from '../entities/metadata-activity-log.entity';
+export declare class MetadataActivityLogRepository extends BaseRepository<MetadataActivityLog> {
+    private readonly activityLogRepository;
+    constructor(activityLogRepository: Repository<MetadataActivityLog>);
+    logActivity(data: {
+        userId: string;
+        workspaceId?: string;
+        sessionId?: string;
+        entityType: string;
+        entityId: string;
+        action: MetadataActivityAction;
+        source?: MetadataActivitySource;
+        metadataBefore?: Record<string, any>;
+        metadataAfter?: Record<string, any>;
+        details?: Record<string, any>;
+        projectId?: string;
+        durationMs?: number;
+    }): Promise<MetadataActivityLog>;
+    findByUserId(userId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByEntity(entityType: string, entityId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByProjectId(projectId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByAction(action: MetadataActivityAction, userId?: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findByDateRange(userId: string, startDate: Date, endDate: Date): Promise<MetadataActivityLog[]>;
+    findRecentEditActions(userId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    findAiInteractions(userId: string, limit?: number): Promise<MetadataActivityLog[]>;
+    getActionCounts(userId: string, startDate?: Date): Promise<Record<string, number>>;
+    getEffectUsageFromLogs(userId: string, startDate?: Date): Promise<Record<string, number>>;
+    getTransitionUsageFromLogs(userId: string, startDate?: Date): Promise<Record<string, number>>;
+    getActivityHeatmap(userId: string, days?: number): Promise<{
+        hourOfDay: Record<number, number>;
+        dayOfWeek: Record<number, number>;
+    }>;
+    cleanupOldLogs(retentionDays?: number): Promise<number>;
+    getSessionSummary(sessionId: string): Promise<{
+        actions: number;
+        duration: number;
+        actionBreakdown: Record<string, number>;
+    }>;
+}

package/dist/repositories/metadata-activity-log.repository.js

@@ -0,0 +1,220 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataActivityLogRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const metadata_activity_log_entity_1 = require("../entities/metadata-activity-log.entity");
+let MetadataActivityLogRepository = class MetadataActivityLogRepository extends base_repository_1.BaseRepository {
+    constructor(activityLogRepository) {
+        super(activityLogRepository);
+        this.activityLogRepository = activityLogRepository;
+    }
+    async logActivity(data) {
+        return this.create({
+            ...data,
+            source: data.source || metadata_activity_log_entity_1.MetadataActivitySource.USER,
+        });
+    }
+    async findByUserId(userId, limit = 100) {
+        return this.activityLogRepository.find({
+            where: { userId },
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByEntity(entityType, entityId, limit = 50) {
+        return this.activityLogRepository.find({
+            where: { entityType, entityId },
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByProjectId(projectId, limit = 100) {
+        return this.activityLogRepository.find({
+            where: { projectId },
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByAction(action, userId, limit = 100) {
+        const where = { action };
+        if (userId) {
+            where.userId = userId;
+        }
+        return this.activityLogRepository.find({
+            where,
+            order: { createdAt: 'DESC' },
+            take: limit,
+        });
+    }
+    async findByDateRange(userId, startDate, endDate) {
+        return this.activityLogRepository.find({
+            where: {
+                userId,
+                createdAt: (0, typeorm_1.Between)(startDate, endDate),
+            },
+            order: { createdAt: 'ASC' },
+        });
+    }
+    async findRecentEditActions(userId, limit = 500) {
+        const editActions = [
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_CLIP_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TRANSITION_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_EFFECT_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TEXT_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_AUDIO_ADDED,
+            metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TRIM,
+        ];
+        return this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action IN (:...actions)', { actions: editActions })
+            .orderBy('al.created_at', 'DESC')
+            .limit(limit)
+            .getMany();
+    }
+    async findAiInteractions(userId, limit = 100) {
+        const aiActions = [
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_CONTEXT_REQUESTED,
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_SUGGESTION_ACCEPTED,
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_SUGGESTION_REJECTED,
+            metadata_activity_log_entity_1.MetadataActivityAction.AI_CONTENT_GENERATED,
+        ];
+        return this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action IN (:...actions)', { actions: aiActions })
+            .orderBy('al.created_at', 'DESC')
+            .limit(limit)
+            .getMany();
+    }
+    async getActionCounts(userId, startDate) {
+        let query = this.activityLogRepository
+            .createQueryBuilder('al')
+            .select('al.action', 'action')
+            .addSelect('COUNT(*)', 'count')
+            .where('al.user_id = :userId', { userId })
+            .groupBy('al.action');
+        if (startDate) {
+            query = query.andWhere('al.created_at >= :startDate', { startDate });
+        }
+        const results = await query.getRawMany();
+        return results.reduce((acc, row) => {
+            acc[row.action] = parseInt(row.count, 10);
+            return acc;
+        }, {});
+    }
+    async getEffectUsageFromLogs(userId, startDate) {
+        let query = this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action = :action', {
+            action: metadata_activity_log_entity_1.MetadataActivityAction.EDIT_EFFECT_ADDED,
+        });
+        if (startDate) {
+            query = query.andWhere('al.created_at >= :startDate', { startDate });
+        }
+        const logs = await query.getMany();
+        const effectCounts = {};
+        for (const log of logs) {
+            const effectName = log.details?.effectName || log.details?.effect || 'unknown';
+            effectCounts[effectName] = (effectCounts[effectName] || 0) + 1;
+        }
+        return effectCounts;
+    }
+    async getTransitionUsageFromLogs(userId, startDate) {
+        let query = this.activityLogRepository
+            .createQueryBuilder('al')
+            .where('al.user_id = :userId', { userId })
+            .andWhere('al.action = :action', {
+            action: metadata_activity_log_entity_1.MetadataActivityAction.EDIT_TRANSITION_ADDED,
+        });
+        if (startDate) {
+            query = query.andWhere('al.created_at >= :startDate', { startDate });
+        }
+        const logs = await query.getMany();
+        const transitionCounts = {};
+        for (const log of logs) {
+            const transitionName = log.details?.transitionName || log.details?.transition || 'unknown';
+            transitionCounts[transitionName] =
+                (transitionCounts[transitionName] || 0) + 1;
+        }
+        return transitionCounts;
+    }
+    async getActivityHeatmap(userId, days = 30) {
+        const startDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const logs = await this.activityLogRepository.find({
+            where: {
+                userId,
+                createdAt: (0, typeorm_1.MoreThan)(startDate),
+            },
+            select: ['createdAt'],
+        });
+        const hourOfDay = {};
+        const dayOfWeek = {};
+        for (const log of logs) {
+            const date = new Date(log.createdAt);
+            const hour = date.getHours();
+            const day = date.getDay();
+            hourOfDay[hour] = (hourOfDay[hour] || 0) + 1;
+            dayOfWeek[day] = (dayOfWeek[day] || 0) + 1;
+        }
+        return { hourOfDay, dayOfWeek };
+    }
+    async cleanupOldLogs(retentionDays = 90) {
+        const cutoffDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
+        const result = await this.activityLogRepository.delete({
+            createdAt: (0, typeorm_1.LessThan)(cutoffDate),
+        });
+        return result.affected ?? 0;
+    }
+    async getSessionSummary(sessionId) {
+        const logs = await this.activityLogRepository.find({
+            where: { sessionId },
+            order: { createdAt: 'ASC' },
+        });
+        if (logs.length === 0) {
+            return { actions: 0, duration: 0, actionBreakdown: {} };
+        }
+        const actionBreakdown = {};
+        let totalDuration = 0;
+        for (const log of logs) {
+            actionBreakdown[log.action] = (actionBreakdown[log.action] || 0) + 1;
+            if (log.durationMs) {
+                totalDuration += log.durationMs;
+            }
+        }
+        if (totalDuration === 0 && logs.length > 1) {
+            const firstLog = logs[0];
+            const lastLog = logs[logs.length - 1];
+            totalDuration =
+                new Date(lastLog.createdAt).getTime() -
+                    new Date(firstLog.createdAt).getTime();
+        }
+        return {
+            actions: logs.length,
+            duration: totalDuration,
+            actionBreakdown,
+        };
+    }
+};
+exports.MetadataActivityLogRepository = MetadataActivityLogRepository;
+exports.MetadataActivityLogRepository = MetadataActivityLogRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(metadata_activity_log_entity_1.MetadataActivityLog)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], MetadataActivityLogRepository);

package/dist/repositories/project-metadata.repository.d.ts

@@ -0,0 +1,32 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { ProjectMetadata } from '../entities/project-metadata.entity';
+export declare class ProjectMetadataRepository extends BaseRepository<ProjectMetadata> {
+    private readonly projectMetadataRepository;
+    constructor(projectMetadataRepository: Repository<ProjectMetadata>);
+    findByProjectId(projectId: string): Promise<ProjectMetadata | null>;
+    findByUserId(userId: string): Promise<ProjectMetadata[]>;
+    findByWorkspaceId(workspaceId: string): Promise<ProjectMetadata[]>;
+    findByProjectType(userId: string, projectType: string): Promise<ProjectMetadata[]>;
+    updateComposition(projectId: string, composition: ProjectMetadata['composition']): Promise<ProjectMetadata | null>;
+    updateStyleFingerprint(projectId: string, styleFingerprint: ProjectMetadata['styleFingerprint']): Promise<ProjectMetadata | null>;
+    updateEmbedding(projectId: string, embedding: number[]): Promise<ProjectMetadata | null>;
+    recordEditSession(projectId: string, sessionDurationMs: number): Promise<void>;
+    addAssetUsed(projectId: string, assetId: string): Promise<void>;
+    incrementEffectUsage(projectId: string, effectName: string): Promise<void>;
+    addExportToHistory(projectId: string, exportData: {
+        format: string;
+        resolution: string;
+        fileSize?: number;
+    }): Promise<void>;
+    recordAiSuggestion(projectId: string, suggestionType: string, accepted: boolean): Promise<void>;
+    findSimilarByEmbedding(embedding: number[], userId: string, limit?: number, excludeProjectId?: string): Promise<Array<ProjectMetadata & {
+        similarity: number;
+    }>>;
+    getStylePreferencesForUser(userId: string): Promise<{
+        topTransitions: Record<string, number>;
+        topEffects: Record<string, number>;
+        avgClipDuration: number;
+        preferredPacing: string;
+    }>;
+}

package/dist/repositories/project-metadata.repository.js

@@ -0,0 +1,186 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectMetadataRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const project_metadata_entity_1 = require("../entities/project-metadata.entity");
+let ProjectMetadataRepository = class ProjectMetadataRepository extends base_repository_1.BaseRepository {
+    constructor(projectMetadataRepository) {
+        super(projectMetadataRepository);
+        this.projectMetadataRepository = projectMetadataRepository;
+    }
+    async findByProjectId(projectId) {
+        return this.projectMetadataRepository.findOne({
+            where: { projectId },
+        });
+    }
+    async findByUserId(userId) {
+        return this.projectMetadataRepository.find({
+            where: { userId },
+            order: { updatedAt: 'DESC' },
+        });
+    }
+    async findByWorkspaceId(workspaceId) {
+        return this.projectMetadataRepository.find({
+            where: { workspaceId },
+            order: { updatedAt: 'DESC' },
+        });
+    }
+    async findByProjectType(userId, projectType) {
+        return this.projectMetadataRepository.find({
+            where: { userId, projectType },
+            order: { updatedAt: 'DESC' },
+        });
+    }
+    async updateComposition(projectId, composition) {
+        await this.projectMetadataRepository.update({ projectId }, { composition });
+        return this.findByProjectId(projectId);
+    }
+    async updateStyleFingerprint(projectId, styleFingerprint) {
+        await this.projectMetadataRepository.update({ projectId }, { styleFingerprint });
+        return this.findByProjectId(projectId);
+    }
+    async updateEmbedding(projectId, embedding) {
+        await this.projectMetadataRepository.update({ projectId }, {
+            projectEmbedding: embedding,
+            embeddingGeneratedAt: new Date(),
+        });
+        return this.findByProjectId(projectId);
+    }
+    async recordEditSession(projectId, sessionDurationMs) {
+        await this.projectMetadataRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            editSessionsCount: () => 'edit_sessions_count + 1',
+            totalEditTimeMs: () => `total_edit_time_ms + ${sessionDurationMs}`,
+        })
+            .where('project_id = :projectId', { projectId })
+            .execute();
+    }
+    async addAssetUsed(projectId, assetId) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const assetsUsed = metadata.assetsUsed || [];
+        if (!assetsUsed.includes(assetId)) {
+            assetsUsed.push(assetId);
+            await this.projectMetadataRepository.update({ projectId }, { assetsUsed });
+        }
+    }
+    async incrementEffectUsage(projectId, effectName) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const effectsUsed = metadata.effectsUsed || {};
+        effectsUsed[effectName] = (effectsUsed[effectName] || 0) + 1;
+        await this.projectMetadataRepository.update({ projectId }, { effectsUsed });
+    }
+    async addExportToHistory(projectId, exportData) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const exportHistory = metadata.exportHistory || [];
+        exportHistory.push({
+            ...exportData,
+            exportedAt: new Date().toISOString(),
+        });
+        await this.projectMetadataRepository.update({ projectId }, { exportHistory });
+    }
+    async recordAiSuggestion(projectId, suggestionType, accepted) {
+        const metadata = await this.findByProjectId(projectId);
+        if (!metadata)
+            return;
+        const aiSuggestionsApplied = metadata.aiSuggestionsApplied || [];
+        aiSuggestionsApplied.push({
+            suggestionType,
+            appliedAt: new Date().toISOString(),
+            accepted,
+        });
+        await this.projectMetadataRepository.update({ projectId }, { aiSuggestionsApplied });
+    }
+    async findSimilarByEmbedding(embedding, userId, limit = 10, excludeProjectId) {
+        const embeddingStr = JSON.stringify(embedding);
+        let query = this.projectMetadataRepository
+            .createQueryBuilder('pm')
+            .select('pm.*')
+            .addSelect(`1 - (pm.project_embedding::vector(1536) <=> '${embeddingStr}'::vector(1536))`, 'similarity')
+            .where('pm.user_id = :userId', { userId })
+            .andWhere('pm.project_embedding IS NOT NULL');
+        if (excludeProjectId) {
+            query = query.andWhere('pm.project_id != :excludeProjectId', {
+                excludeProjectId,
+            });
+        }
+        const results = await query
+            .orderBy('similarity', 'DESC')
+            .limit(limit)
+            .getRawMany();
+        return results;
+    }
+    async getStylePreferencesForUser(userId) {
+        const projects = await this.projectMetadataRepository.find({
+            where: { userId },
+            select: ['styleFingerprint', 'effectsUsed'],
+        });
+        const transitions = {};
+        const effects = {};
+        let totalClipDuration = 0;
+        let clipDurationCount = 0;
+        const pacingCounts = {};
+        for (const project of projects) {
+            if (project.styleFingerprint?.transitions) {
+                for (const t of project.styleFingerprint.transitions) {
+                    transitions[t] = (transitions[t] || 0) + 1;
+                }
+            }
+            if (project.effectsUsed) {
+                for (const [effect, count] of Object.entries(project.effectsUsed)) {
+                    effects[effect] = (effects[effect] || 0) + count;
+                }
+            }
+            if (project.styleFingerprint?.avgClipDuration) {
+                totalClipDuration += project.styleFingerprint.avgClipDuration;
+                clipDurationCount++;
+            }
+            if (project.styleFingerprint?.pacing) {
+                pacingCounts[project.styleFingerprint.pacing] =
+                    (pacingCounts[project.styleFingerprint.pacing] || 0) + 1;
+            }
+        }
+        let preferredPacing = 'medium';
+        let maxPacingCount = 0;
+        for (const [pacing, count] of Object.entries(pacingCounts)) {
+            if (count > maxPacingCount) {
+                maxPacingCount = count;
+                preferredPacing = pacing;
+            }
+        }
+        return {
+            topTransitions: transitions,
+            topEffects: effects,
+            avgClipDuration: clipDurationCount > 0 ? totalClipDuration / clipDurationCount : 0,
+            preferredPacing,
+        };
+    }
+};
+exports.ProjectMetadataRepository = ProjectMetadataRepository;
+exports.ProjectMetadataRepository = ProjectMetadataRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(project_metadata_entity_1.ProjectMetadata)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], ProjectMetadataRepository);

package/dist/repositories/repository.module.js

@@ -37,6 +37,11 @@ const repositories = [
     _1.VideoRenderRepository,
     _1.VideoFilmstripRepository,
     _1.AudioWaveformRepository,
+    _1.AssetMetadataRepository,
+    _1.ProjectMetadataRepository,
+    _1.UserContextRepository,
+    _1.AiEmbeddingRepository,
+    _1.MetadataActivityLogRepository,
 ];
 const entities = [
     entities_1.User,
@@ -64,6 +69,11 @@ const entities = [
     entities_1.VideoRender,
     entities_1.VideoFilmstrip,
     entities_1.AudioWaveform,
+    entities_1.AssetMetadata,
+    entities_1.ProjectMetadata,
+    entities_1.UserContext,
+    entities_1.AiEmbedding,
+    entities_1.MetadataActivityLog,
 ];
 let RepositoryModule = class RepositoryModule {
 };

package/dist/repositories/user-context.repository.d.ts

@@ -0,0 +1,66 @@
+import { Repository } from 'typeorm';
+import { BaseRepository } from './base.repository';
+import { UserContext } from '../entities/user-context.entity';
+export declare class UserContextRepository extends BaseRepository<UserContext> {
+    private readonly userContextRepository;
+    constructor(userContextRepository: Repository<UserContext>);
+    findByUserId(userId: string): Promise<UserContext | null>;
+    getOrCreate(userId: string): Promise<UserContext>;
+    updateStylePreferences(userId: string, preferences: {
+        preferredStyles?: string[];
+        preferredGenres?: string[];
+        preferredTransitions?: string[];
+        preferredEffects?: string[];
+        preferredFonts?: string[];
+    }): Promise<UserContext | null>;
+    updateDefaultSettings(userId: string, settings: {
+        defaultAspectRatio?: string;
+        defaultResolution?: string;
+        defaultFps?: number;
+    }): Promise<UserContext | null>;
+    updateBrandAssets(userId: string, brandAssets: {
+        brandColors?: UserContext['brandColors'];
+        brandFonts?: UserContext['brandFonts'];
+        brandLogoAssetIds?: string[];
+        brandWatermarkAssetId?: string;
+    }): Promise<UserContext | null>;
+    updateBehavioralAnalytics(userId: string, analytics: {
+        avgProjectDurationMs?: number;
+        avgSessionLengthMs?: number;
+        mostUsedEffects?: Record<string, number>;
+        mostUsedTransitions?: Record<string, number>;
+        editingPatterns?: UserContext['editingPatterns'];
+        skillLevel?: UserContext['skillLevel'];
+        activityHeatmap?: UserContext['activityHeatmap'];
+    }): Promise<UserContext | null>;
+    incrementProjectCount(userId: string, completed?: boolean): Promise<void>;
+    addEditTime(userId: string, durationMs: number): Promise<void>;
+    recordAiInteraction(userId: string, accepted: boolean): Promise<void>;
+    addRecentPrompt(userId: string, prompt: string, successful: boolean): Promise<void>;
+    updateEmbedding(userId: string, embedding: number[]): Promise<UserContext | null>;
+    markAggregated(userId: string): Promise<void>;
+    findNeedingAggregation(limit?: number): Promise<UserContext[]>;
+    getAiContext(userId: string): Promise<{
+        preferences: {
+            styles: string[];
+            genres: string[];
+            transitions: string[];
+            effects: string[];
+        };
+        defaults: {
+            aspectRatio: string;
+            resolution: string;
+            fps: number;
+        };
+        analytics: {
+            totalProjects: number;
+            avgProjectDuration: number;
+            skillLevel: string;
+            preferredPacing: string;
+        };
+        brand: {
+            colors: UserContext['brandColors'];
+            fonts: UserContext['brandFonts'];
+        };
+    } | null>;
+}

package/dist/repositories/user-context.repository.js

@@ -0,0 +1,161 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserContextRepository = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const typeorm_2 = require("@nestjs/typeorm");
+const base_repository_1 = require("./base.repository");
+const user_context_entity_1 = require("../entities/user-context.entity");
+let UserContextRepository = class UserContextRepository extends base_repository_1.BaseRepository {
+    constructor(userContextRepository) {
+        super(userContextRepository);
+        this.userContextRepository = userContextRepository;
+    }
+    async findByUserId(userId) {
+        return this.userContextRepository.findOne({
+            where: { userId },
+        });
+    }
+    async getOrCreate(userId) {
+        let context = await this.findByUserId(userId);
+        if (!context) {
+            context = await this.create({ userId });
+        }
+        return context;
+    }
+    async updateStylePreferences(userId, preferences) {
+        await this.userContextRepository.update({ userId }, preferences);
+        return this.findByUserId(userId);
+    }
+    async updateDefaultSettings(userId, settings) {
+        await this.userContextRepository.update({ userId }, settings);
+        return this.findByUserId(userId);
+    }
+    async updateBrandAssets(userId, brandAssets) {
+        await this.userContextRepository.update({ userId }, brandAssets);
+        return this.findByUserId(userId);
+    }
+    async updateBehavioralAnalytics(userId, analytics) {
+        await this.userContextRepository.update({ userId }, analytics);
+        return this.findByUserId(userId);
+    }
+    async incrementProjectCount(userId, completed = false) {
+        const updates = {
+            totalProjectsCount: () => 'total_projects_count + 1',
+        };
+        if (completed) {
+            updates.completedProjectsCount = () => 'completed_projects_count + 1';
+        }
+        await this.userContextRepository
+            .createQueryBuilder()
+            .update()
+            .set(updates)
+            .where('user_id = :userId', { userId })
+            .execute();
+    }
+    async addEditTime(userId, durationMs) {
+        await this.userContextRepository
+            .createQueryBuilder()
+            .update()
+            .set({
+            totalEditTimeMs: () => `total_edit_time_ms + ${durationMs}`,
+        })
+            .where('user_id = :userId', { userId })
+            .execute();
+    }
+    async recordAiInteraction(userId, accepted) {
+        const updates = {
+            aiPromptsCount: () => 'ai_prompts_count + 1',
+        };
+        if (accepted) {
+            updates.aiSuggestionsAccepted = () => 'ai_suggestions_accepted + 1';
+        }
+        else {
+            updates.aiSuggestionsRejected = () => 'ai_suggestions_rejected + 1';
+        }
+        await this.userContextRepository
+            .createQueryBuilder()
+            .update()
+            .set(updates)
+            .where('user_id = :userId', { userId })
+            .execute();
+    }
+    async addRecentPrompt(userId, prompt, successful) {
+        const context = await this.findByUserId(userId);
+        if (!context)
+            return;
+        const recentPrompts = context.recentPrompts || [];
+        recentPrompts.unshift({
+            prompt,
+            timestamp: new Date().toISOString(),
+            successful,
+        });
+        const trimmedPrompts = recentPrompts.slice(0, 20);
+        await this.userContextRepository.update({ userId }, { recentPrompts: trimmedPrompts });
+    }
+    async updateEmbedding(userId, embedding) {
+        await this.userContextRepository.update({ userId }, {
+            userEmbedding: embedding,
+            embeddingGeneratedAt: new Date(),
+        });
+        return this.findByUserId(userId);
+    }
+    async markAggregated(userId) {
+        await this.userContextRepository.update({ userId }, { lastAggregatedAt: new Date() });
+    }
+    async findNeedingAggregation(limit = 100) {
+        const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        return this.userContextRepository
+            .createQueryBuilder('uc')
+            .where('(uc.last_aggregated_at IS NULL OR uc.last_aggregated_at < :oneDayAgo)', { oneDayAgo })
+            .orderBy('uc.last_aggregated_at', 'ASC', 'NULLS FIRST')
+            .limit(limit)
+            .getMany();
+    }
+    async getAiContext(userId) {
+        const context = await this.findByUserId(userId);
+        if (!context)
+            return null;
+        return {
+            preferences: {
+                styles: context.preferredStyles || [],
+                genres: context.preferredGenres || [],
+                transitions: context.preferredTransitions || [],
+                effects: context.preferredEffects || [],
+            },
+            defaults: {
+                aspectRatio: context.defaultAspectRatio || '16:9',
+                resolution: context.defaultResolution || '1080p',
+                fps: context.defaultFps || 30,
+            },
+            analytics: {
+                totalProjects: context.totalProjectsCount || 0,
+                avgProjectDuration: context.avgProjectDurationMs || 0,
+                skillLevel: context.skillLevel || 'beginner',
+                preferredPacing: context.editingPatterns?.preferredPacing || 'medium',
+            },
+            brand: {
+                colors: context.brandColors,
+                fonts: context.brandFonts,
+            },
+        };
+    }
+};
+exports.UserContextRepository = UserContextRepository;
+exports.UserContextRepository = UserContextRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(user_context_entity_1.UserContext)),
+    __metadata("design:paramtypes", [typeorm_1.Repository])
+], UserContextRepository);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clhq-postgres-module",
-  "version": "1.1.0-alpha.106",
+  "version": "1.1.0-alpha.107",
   "description": "PostgreSQL module using TypeORM for Clippy",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",