@lynxflow/seo-engine 2.8.0 → 3.2.1

package/dist/bi-enterprise-suite.d.ts

@@ -0,0 +1,278 @@
+/**
+ * 🏢 BI Enterprise Suite — équivalents fonctionnels « entreprise »
+ *
+ * Implémentation **originale** des briques qu'un outil de BI vend
+ * habituellement dans son offre entreprise :
+ *
+ * | Brique | Ce que ça remplace |
+ * |---|---|
+ * | `AuditLog` | journal d'audit des accès/requêtes |
+ * | `EmbedTokenIssuer` | embedding signé (JWT HS256), dashboards et questions |
+ * | `DataSandbox` | permissions au niveau ligne (data sandboxing) |
+ * | `serializeBundle` / `importBundle` | sérialisation d'un contenu BI entre environnements |
+ * | `BiQueryCache` | cache de résultats avec TTL et invalidation par table |
+ * | `ContentVerifier` | revue de fraîcheur « verified content » |
+ * | `PermissionMatrix` | permissions par collection avec héritage |
+ *
+ * **Frontière de licence** : aucun code propriétaire n'est repris. Le
+ * composant « enterprise » du BI de référence est sous licence commerciale et reste
+ * interdit par `AGENTS.md` (§8) et `provenance-guard.test.ts`, même avec un
+ * accord par email : un accord commercial ne rend pas le code AGPL-compatible.
+ * Les *fonctionnalités* ne sont pas protégeables, leur *implémentation* l'est —
+ * d'où ce module écrit de zéro, sans lecture du corpus `inspiration/`.
+ */
+import type { SqlDialect } from "./semantic/dialects/types";
+export type AuditAction = "query.execute" | "query.export" | "dashboard.view" | "dashboard.edit" | "embed.issue" | "permission.grant" | "permission.revoke" | "content.verify" | "login" | "logout";
+export interface AuditEntryInput {
+    actorId: string;
+    actorEmail?: string;
+    action: AuditAction;
+    targetType: "dashboard" | "question" | "collection" | "database" | "session" | "embed";
+    targetId: string;
+    metadata?: Record<string, unknown>;
+    at?: string;
+}
+export interface AuditEntry extends AuditEntryInput {
+    id: string;
+    at: string;
+    prevHash: string;
+    hash: string;
+}
+export interface AuditFilter {
+    actorId?: string;
+    action?: AuditAction;
+    targetId?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+}
+/**
+ * Journal append-only avec chaîne de hachage : toute suppression ou
+ * modification d'une entrée casse `verifyChain()`. Aucun `Math.random()` :
+ * l'identifiant dérive du contenu et de la position.
+ */
+export declare class AuditLog {
+    private readonly entries;
+    private readonly now;
+    private readonly genesis;
+    constructor(options?: {
+        now?: () => Date;
+    });
+    append(input: AuditEntryInput): AuditEntry;
+    list(filter?: AuditFilter): AuditEntry[];
+    /**
+     * Recharge un journal persisté (D1/Postgres). Le contenu n'est pas réécrit :
+     * `verifyChain()` reste la seule autorité sur son intégrité.
+     */
+    restore(entries: readonly AuditEntry[]): void;
+    verifyChain(): {
+        valid: boolean;
+        brokenAt?: number;
+    };
+    exportNdjson(): string;
+}
+export interface EmbedResource {
+    dashboard?: string | number;
+    question?: string | number;
+    collection?: string | number;
+}
+export interface EmbedClaims {
+    iss: "lynxseo";
+    sub: string;
+    iat: number;
+    exp: number;
+    resource: EmbedResource;
+    params?: Record<string, string | number | boolean>;
+    groupId?: string;
+}
+export interface EmbedIssueOptions {
+    resource: EmbedResource;
+    /** Identifiant du viewer (email ou id) : jamais un secret. */
+    subject: string;
+    groupId?: string;
+    params?: Record<string, string | number | boolean>;
+    /** Durée de vie en secondes (10 min par défaut). */
+    ttlSeconds?: number;
+}
+/**
+ * Émet et vérifie les jetons d'intégration.
+ *
+ * Un jeton ne donne accès qu'à une ressource et à des paramètres figés : le
+ * dashboard ne peut pas être « élargi » côté client. Le secret reste côté
+ * serveur, jamais dans l'iframe.
+ */
+export declare class EmbedTokenIssuer {
+    private readonly secret;
+    private readonly issuer;
+    private readonly now;
+    constructor(options: {
+        secret: string;
+        now?: () => Date;
+    });
+    issue(options: EmbedIssueOptions): {
+        token: string;
+        claims: EmbedClaims;
+    };
+    verify(token: string, options?: {
+        nowSeconds?: number;
+        toleranceSeconds?: number;
+    }): {
+        valid: boolean;
+        claims?: EmbedClaims;
+        reason?: string;
+    };
+}
+export interface SandboxRule {
+    groupId: string;
+    /** Attribut du viewer (ex. `tenant_id`). */
+    attribute: string;
+    /** Attributs exposés par le viewer (clé = nom d'attribut). */
+    value: string | number;
+}
+export interface SandboxCompileOptions {
+    groupId: string;
+    attributes: Readonly<Record<string, string | number>>;
+    /** Correspondance attribut viewer → colonne SQL. */
+    columnByAttribute: Readonly<Record<string, string>>;
+    dialect: SqlDialect;
+}
+export declare class MissingSandboxPolicyError extends Error {
+    constructor(groupId: string);
+}
+/**
+ * Traduit l'appartenance à un groupe en prédicat SQL paramétré.
+ *
+ * Fail-closed : un groupe sans politique, ou un attribut manquant, lève une
+ * erreur au lieu de renvoyer toutes les lignes.
+ */
+export declare class DataSandbox {
+    private readonly rules;
+    constructor(rules: readonly SandboxRule[]);
+    isRestricted(groupId: string): boolean;
+    compile(options: SandboxCompileOptions): {
+        sql: string;
+        params: unknown[];
+        column: string;
+        value: string | number;
+    };
+}
+export type SerializedItemType = "dashboard" | "question" | "collection" | "pulse";
+export interface SerializedItem {
+    id: string;
+    type: SerializedItemType;
+    name: string;
+    payload: Record<string, unknown>;
+    /** Identifiants d'autres items requis avant celui-ci. */
+    dependsOn?: readonly string[];
+}
+export interface SerializedBundle {
+    version: 1;
+    exportedAt: string;
+    items: SerializedItem[];
+    checksum: string;
+}
+export interface ImportReport {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+    /** Ordre d'import (dépendances d'abord). */
+    order: string[];
+}
+export declare function bundleChecksum(items: readonly SerializedItem[]): string;
+/** Sérialise un bundle trié et signé (checksum), pour Git ou un autre env. */
+export declare function serializeBundle(items: readonly SerializedItem[], options?: {
+    now?: Date;
+}): SerializedBundle;
+/** Tri topologique (dépendances d'abord), avec détection de cycle. */
+export declare function planImportOrder(items: readonly SerializedItem[]): string[];
+export declare function importBundle(bundle: SerializedBundle, existingIds: readonly string[], options?: {
+    mode?: "create" | "update" | "skip";
+}): ImportReport;
+export interface BiCacheEntry {
+    value: unknown;
+    storedAt: string;
+    expiresAt: string;
+    tables: string[];
+    hits: number;
+}
+export declare function cacheKey(dataset: string, sql: string, params: unknown): string;
+/**
+ * Cache LRU avec TTL et invalidation par table.
+ *
+ * Une requête qui touche `pulse_events` est invalidée dès qu'un import
+ * d'événements écrit dans cette table : plus de dashboards « périmés sans le
+ * dire ».
+ */
+export declare class BiQueryCache {
+    private readonly entries;
+    private readonly maxEntries;
+    private readonly now;
+    private hits;
+    private misses;
+    private evictions;
+    constructor(options?: {
+        maxEntries?: number;
+        now?: () => Date;
+    });
+    get(key: string): {
+        hit: boolean;
+        value?: unknown;
+        ageMs?: number;
+    };
+    set(key: string, value: unknown, options: {
+        ttlSeconds: number;
+        tables: readonly string[];
+    }): void;
+    invalidateTables(tables: readonly string[]): number;
+    stats(): {
+        size: number;
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+}
+export interface VerificationRecord {
+    itemId: string;
+    verifiedAt: string;
+    verifiedBy: string;
+    reviewAfterDays: number;
+}
+export interface VerificationStatus {
+    verified: boolean;
+    verifiedAt?: string;
+    verifiedBy?: string;
+    dueAt?: string;
+    stale: boolean;
+}
+export declare class ContentVerifier {
+    private readonly records;
+    private readonly now;
+    constructor(options?: {
+        now?: () => Date;
+    });
+    markVerified(options: {
+        itemId: string;
+        verifiedBy: string;
+        reviewAfterDays?: number;
+        at?: string;
+    }): VerificationRecord;
+    getStatus(itemId: string): VerificationStatus;
+    listStale(itemIds: readonly string[]): string[];
+}
+export declare const COLLECTION_ACCESS: readonly ["none", "view", "edit", "manage"];
+export type CollectionAccess = (typeof COLLECTION_ACCESS)[number];
+export interface CollectionGrant {
+    groupId: string;
+    collectionId: string;
+    access: CollectionAccess;
+}
+/**
+ * Permission la plus spécifique gagne : un droit sur `a/b/c` prime sur `a/b`
+ * qui prime sur `a`. Une collection non couverte est refusée.
+ */
+export declare class PermissionMatrix {
+    private readonly grants;
+    constructor(grants: readonly CollectionGrant[]);
+    resolve(groupId: string, collectionId: string): CollectionAccess;
+    can(groupId: string, collectionId: string, required: CollectionAccess): boolean;
+}

package/dist/boards/rollup.d.ts

@@ -0,0 +1,19 @@
+export interface BoardRollupItem {
+    siteId: string;
+    siteName?: string;
+    projects: number;
+    tasksOpen: number;
+    tasksDone: number;
+    issuesOpen: number;
+    lastActivityAt?: string;
+}
+export interface BoardRollup {
+    totalSites: number;
+    totalProjects: number;
+    totalTasksOpen: number;
+    totalTasksDone: number;
+    totalIssuesOpen: number;
+    items: BoardRollupItem[];
+    updatedAt: string;
+}
+export declare function computeBoardRollup(items: BoardRollupItem[]): BoardRollup;

package/dist/boards-rollup.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 📊 Boards & Multi-Project Rollup (gap G6)
+ *
+ * Dashboard de rollup agrégeant les métriques de tous les projets d'une
+ * organisation. Inspiré des boards Umami (boardComponentRegistry) et du
+ * concept de rollup multi-site de Rybbit.
+ *
+ * Fournit :
+ * - Enregistrement de widgets de board (BoardWidgetRegistry)
+ * - Calcul de métriques rollup par organisation (projets, trafic, conversions)
+ * - Vue agrégée multi-projets avec comparaisons
+ * - Export de la configuration de board
+ *
+ * Zéro dépendance, pur TypeScript.
+ */
+export interface BoardWidget {
+    id: string;
+    name: string;
+    type: "metric-card" | "line-chart" | "bar-chart" | "table" | "pie-chart" | "stat";
+    config: Record<string, unknown>;
+    projectId?: string;
+    projectIds?: string[];
+    position: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface BoardLayout {
+    id: string;
+    name: string;
+    orgId: string;
+    projectIds: string[];
+    widgets: BoardWidget[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ProjectMetric {
+    projectId: string;
+    projectName: string;
+    visitors: number;
+    pageviews: number;
+    conversions: number;
+    bounceRate: number;
+    avgSessionDurationSec: number;
+}
+export interface OrgRollup {
+    orgId: string;
+    totalProjects: number;
+    totalVisitors: number;
+    totalPageviews: number;
+    totalConversions: number;
+    avgBounceRate: number;
+    avgSessionDurationSec: number;
+    topProjects: ProjectMetric[];
+    generatedAt: string;
+}
+export interface BoardWidgetRegistryEntry {
+    type: BoardWidget["type"];
+    component: string;
+    defaultConfig: Record<string, unknown>;
+}
+/**
+ * Registre des widgets de board disponibles.
+ * Les widgets peuvent être spécifiques à un projet ou agrégés (tous projets).
+ */
+export declare class BoardWidgetRegistry {
+    private widgets;
+    register(entry: BoardWidgetRegistryEntry): void;
+    get(type: BoardWidget["type"]): BoardWidgetRegistryEntry | undefined;
+    list(): BoardWidgetRegistryEntry[];
+    has(type: BoardWidget["type"]): boolean;
+}
+export declare const defaultBoardWidgetRegistry: BoardWidgetRegistry;
+/**
+ * Calcule un rollup d'organisation à partir des métriques par projet.
+ */
+export declare function computeOrgRollup(orgId: string, projectMetrics: ProjectMetric[]): OrgRollup;
+/**
+ * Agrège les métriques de plusieurs projets en une vue rollup.
+ * Chaque projet contribue ses métriques ; le rollup donne une vue d'ensemble
+ * de l'organisation.
+ */
+export declare function rollupProjects(orgId: string, projects: Array<{
+    projectId: string;
+    projectName: string;
+    visitors: number;
+    pageviews: number;
+    conversions: number;
+    bounceRate: number;
+    avgSessionDurationSec: number;
+}>): OrgRollup;
+/**
+ * Crée une configuration de board par défaut pour une organisation.
+ */
+export declare function createDefaultBoard(orgId: string, projectIds: string[], _projectNames: Record<string, string>): BoardLayout;

package/dist/bookmarks-importer.d.ts

@@ -0,0 +1,29 @@
+export interface ImportedBookmark {
+    url: string;
+    title: string;
+    folderPath: string[];
+    tags: string[];
+    addDate?: Date;
+    description?: string;
+}
+export interface BookmarksParseResult {
+    totalCount: number;
+    folders: string[];
+    bookmarks: ImportedBookmark[];
+}
+export declare class BookmarksImporter {
+    /**
+     * Parses standard Netscape Bookmark HTML format (Chrome, Firefox, Safari, Linkwarden).
+     */
+    static parseNetscapeHtml(html: string): BookmarksParseResult;
+    /**
+     * Generates a standard Netscape Bookmark HTML file from an array of links.
+     */
+    static exportNetscapeHtml(links: Array<{
+        url: string;
+        title: string;
+        folder?: string;
+        tags?: string[];
+        createdAt?: string | Date;
+    }>): string;
+}

package/dist/bulk-seo-orchestrator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ⚡ Bulk SEO Orchestrator
+ *
+ * High-throughput batch processor designed for massive SEO analysis (up to 3,000+ entries):
+ * - Chunk partitioning with zero-memory-leak streaming
+ * - Automatic deduplication and normalization
+ * - Instant KVI opportunity calculation and traffic valuation
+ * - Direct CSV export formatted for Google Sheets, Excel, or BigQuery
+ */
+export interface BulkKeywordItem {
+    keyword: string;
+    monthlySearchVolume?: number;
+    cpcEur?: number;
+    allintitleCount?: number;
+    currentPosition?: number;
+}
+export interface ProcessedBulkKeyword {
+    keyword: string;
+    volume: number;
+    cpcEur: number;
+    allintitle: number;
+    kviScore: number;
+    kviTier: string;
+    estimatedMonthlyValueEur: number;
+    rankPosition?: number;
+}
+export interface BulkProcessingOptions {
+    chunkSize?: number;
+    defaultCpcEur?: number;
+    defaultAllintitle?: number;
+    minVolume?: number;
+}
+export interface BulkProcessingResult {
+    totalSubmitted: number;
+    totalUniqueProcessed: number;
+    totalMonthlyVolume: number;
+    totalEstimatedTrafficValueEur: number;
+    goldMineCount: number;
+    topOpportunities: ProcessedBulkKeyword[];
+    csvExportString: string;
+}
+export declare class BulkSeoOrchestrator {
+    /**
+     * Partitions an array of items into equal chunks for memory-safe processing.
+     */
+    static partitionChunks<T>(items: T[], chunkSize?: number): T[][];
+    /**
+     * Processes up to 3,000+ keywords in a single high-efficiency pipeline.
+     */
+    static processBulkKeywords(items: BulkKeywordItem[], options?: BulkProcessingOptions): BulkProcessingResult;
+}