weave-typescript 0.51.3 → 0.52.0

package/dist/weavesql/weavedb/document_consolidation_sql.d.ts

@@ -0,0 +1,217 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const createConsolidationRunQuery = "-- name: CreateConsolidationRun :one\nINSERT INTO weave.consolidation_runs (\n    id,\n    organization_id,\n    status\n) VALUES (\n    $1,\n    $2,\n    $3\n)\nRETURNING\n    id,\n    organization_id,\n    status,\n    thread_count,\n    cluster_count,\n    hierarchy_depth,\n    error,\n    started_at,\n    completed_at";
+export interface CreateConsolidationRunArgs {
+    id: string;
+    organizationId: string;
+    status: string;
+}
+export interface CreateConsolidationRunRow {
+    id: string;
+    organizationId: string;
+    status: string;
+    threadCount: number;
+    clusterCount: number;
+    hierarchyDepth: number;
+    error: string;
+    startedAt: Date;
+    completedAt: Date | null;
+}
+export declare function createConsolidationRun(client: Client, args: CreateConsolidationRunArgs): Promise<CreateConsolidationRunRow | null>;
+export declare const getConsolidationRunByOrganizationAndIDQuery = "-- name: GetConsolidationRunByOrganizationAndID :one\nSELECT\n    id,\n    organization_id,\n    status,\n    thread_count,\n    cluster_count,\n    hierarchy_depth,\n    error,\n    started_at,\n    completed_at\nFROM weave.consolidation_runs\nWHERE organization_id = $1\n  AND id = $2";
+export interface GetConsolidationRunByOrganizationAndIDArgs {
+    organizationId: string;
+    id: string;
+}
+export interface GetConsolidationRunByOrganizationAndIDRow {
+    id: string;
+    organizationId: string;
+    status: string;
+    threadCount: number;
+    clusterCount: number;
+    hierarchyDepth: number;
+    error: string;
+    startedAt: Date;
+    completedAt: Date | null;
+}
+export declare function getConsolidationRunByOrganizationAndID(client: Client, args: GetConsolidationRunByOrganizationAndIDArgs): Promise<GetConsolidationRunByOrganizationAndIDRow | null>;
+export declare const updateConsolidationRunStateQuery = "-- name: UpdateConsolidationRunState :one\nUPDATE weave.consolidation_runs\nSET\n    status = $1,\n    thread_count = $2,\n    cluster_count = $3,\n    hierarchy_depth = $4,\n    error = $5,\n    completed_at = $6\nWHERE id = $7\n  AND organization_id = $8\nRETURNING\n    id,\n    organization_id,\n    status,\n    thread_count,\n    cluster_count,\n    hierarchy_depth,\n    error,\n    started_at,\n    completed_at";
+export interface UpdateConsolidationRunStateArgs {
+    status: string;
+    threadCount: number;
+    clusterCount: number;
+    hierarchyDepth: number;
+    error: string;
+    completedAt: Date | null;
+    id: string;
+    organizationId: string;
+}
+export interface UpdateConsolidationRunStateRow {
+    id: string;
+    organizationId: string;
+    status: string;
+    threadCount: number;
+    clusterCount: number;
+    hierarchyDepth: number;
+    error: string;
+    startedAt: Date;
+    completedAt: Date | null;
+}
+export declare function updateConsolidationRunState(client: Client, args: UpdateConsolidationRunStateArgs): Promise<UpdateConsolidationRunStateRow | null>;
+export declare const listConsolidationRunsByOrganizationQuery = "-- name: ListConsolidationRunsByOrganization :many\nSELECT\n    id,\n    organization_id,\n    status,\n    thread_count,\n    cluster_count,\n    hierarchy_depth,\n    error,\n    started_at,\n    completed_at\nFROM weave.consolidation_runs\nWHERE organization_id = $1\nORDER BY started_at DESC\nLIMIT $3 OFFSET $2";
+export interface ListConsolidationRunsByOrganizationArgs {
+    organizationId: string;
+    pageOffset: string;
+    pageSize: string;
+}
+export interface ListConsolidationRunsByOrganizationRow {
+    id: string;
+    organizationId: string;
+    status: string;
+    threadCount: number;
+    clusterCount: number;
+    hierarchyDepth: number;
+    error: string;
+    startedAt: Date;
+    completedAt: Date | null;
+}
+export declare function listConsolidationRunsByOrganization(client: Client, args: ListConsolidationRunsByOrganizationArgs): Promise<ListConsolidationRunsByOrganizationRow[]>;
+export declare const upsertConceptClusterQuery = "-- name: UpsertConceptCluster :one\nINSERT INTO weave.concept_clusters (\n    id,\n    organization_id,\n    scope_kind,\n    scope_key,\n    name,\n    description,\n    knowledge_type,\n    level,\n    parent_id,\n    embedding,\n    centroid,\n    thread_count,\n    consolidation_run_id\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8,\n    $9,\n    $10::vector,\n    $11::vector,\n    $12,\n    $13\n)\nON CONFLICT (id) DO UPDATE\nSET\n    name = EXCLUDED.name,\n    description = EXCLUDED.description,\n    scope_kind = EXCLUDED.scope_kind,\n    scope_key = EXCLUDED.scope_key,\n    knowledge_type = EXCLUDED.knowledge_type,\n    level = EXCLUDED.level,\n    parent_id = EXCLUDED.parent_id,\n    embedding = EXCLUDED.embedding,\n    centroid = EXCLUDED.centroid,\n    thread_count = EXCLUDED.thread_count,\n    consolidation_run_id = EXCLUDED.consolidation_run_id,\n    updated_at = now()\nRETURNING\n    id,\n    organization_id,\n    scope_kind,\n    scope_key,\n    name,\n    description,\n    knowledge_type,\n    level,\n    parent_id,\n    thread_count,\n    consolidation_run_id,\n    created_at,\n    updated_at";
+export interface UpsertConceptClusterArgs {
+    id: string;
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    name: string;
+    description: string;
+    knowledgeType: string;
+    level: number;
+    parentId: string | null;
+    embedding: string;
+    centroid: string;
+    threadCount: number;
+    consolidationRunId: string;
+}
+export interface UpsertConceptClusterRow {
+    id: string;
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    name: string;
+    description: string;
+    knowledgeType: string;
+    level: number;
+    parentId: string | null;
+    threadCount: number;
+    consolidationRunId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function upsertConceptCluster(client: Client, args: UpsertConceptClusterArgs): Promise<UpsertConceptClusterRow | null>;
+export declare const getConceptClusterByOrganizationScopeAndIDQuery = "-- name: GetConceptClusterByOrganizationScopeAndID :one\nSELECT\n    id,\n    organization_id,\n    scope_kind,\n    scope_key,\n    name,\n    description,\n    knowledge_type,\n    level,\n    parent_id,\n    thread_count,\n    consolidation_run_id,\n    created_at,\n    updated_at\nFROM weave.concept_clusters\nWHERE organization_id = $1\n  AND scope_kind = $2\n  AND scope_key = $3\n  AND id = $4";
+export interface GetConceptClusterByOrganizationScopeAndIDArgs {
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    id: string;
+}
+export interface GetConceptClusterByOrganizationScopeAndIDRow {
+    id: string;
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    name: string;
+    description: string;
+    knowledgeType: string;
+    level: number;
+    parentId: string | null;
+    threadCount: number;
+    consolidationRunId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function getConceptClusterByOrganizationScopeAndID(client: Client, args: GetConceptClusterByOrganizationScopeAndIDArgs): Promise<GetConceptClusterByOrganizationScopeAndIDRow | null>;
+export declare const listConceptClustersByScopeQuery = "-- name: ListConceptClustersByScope :many\nSELECT\n    id,\n    organization_id,\n    scope_kind,\n    scope_key,\n    name,\n    description,\n    knowledge_type,\n    level,\n    parent_id,\n    thread_count,\n    consolidation_run_id,\n    created_at,\n    updated_at\nFROM weave.concept_clusters\nWHERE organization_id = $1\n  AND scope_kind = $2\n  AND scope_key = $3\n  AND ($4 = '' OR knowledge_type = $4)\n  AND ($5 <= 0 OR level <= $5)\nORDER BY level ASC, updated_at DESC, id ASC";
+export interface ListConceptClustersByScopeArgs {
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    knowledgeType: string | null;
+    maxDepth: string | null;
+}
+export interface ListConceptClustersByScopeRow {
+    id: string;
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    name: string;
+    description: string;
+    knowledgeType: string;
+    level: number;
+    parentId: string | null;
+    threadCount: number;
+    consolidationRunId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function listConceptClustersByScope(client: Client, args: ListConceptClustersByScopeArgs): Promise<ListConceptClustersByScopeRow[]>;
+export declare const listConceptClustersByParentAndScopeQuery = "-- name: ListConceptClustersByParentAndScope :many\nSELECT\n    id,\n    organization_id,\n    scope_kind,\n    scope_key,\n    name,\n    description,\n    knowledge_type,\n    level,\n    parent_id,\n    thread_count,\n    consolidation_run_id,\n    created_at,\n    updated_at\nFROM weave.concept_clusters\nWHERE organization_id = $1\n  AND scope_kind = $2\n  AND scope_key = $3\n  AND parent_id = $4\nORDER BY updated_at DESC, id ASC";
+export interface ListConceptClustersByParentAndScopeArgs {
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    parentId: string | null;
+}
+export interface ListConceptClustersByParentAndScopeRow {
+    id: string;
+    organizationId: string;
+    scopeKind: string;
+    scopeKey: string;
+    name: string;
+    description: string;
+    knowledgeType: string;
+    level: number;
+    parentId: string | null;
+    threadCount: number;
+    consolidationRunId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function listConceptClustersByParentAndScope(client: Client, args: ListConceptClustersByParentAndScopeArgs): Promise<ListConceptClustersByParentAndScopeRow[]>;
+export declare const listApprovedThreadsForConsolidationQuery = "-- name: ListApprovedThreadsForConsolidation :many\nSELECT\n    t.id,\n    t.organization_id,\n    t.document_id,\n    t.ingestion_run_id,\n    t.text,\n    t.knowledge_type,\n    t.embedding::text AS embedding_text,\n    t.approved_at,\n    CASE\n        WHEN d.scope = 'DOCUMENT_SCOPE_ORG'\n            THEN 'SCOPE_KIND_ORG'::text\n        WHEN d.scope = 'DOCUMENT_SCOPE_RESTRICTED'\n            THEN 'SCOPE_KIND_RESTRICTED_GROUP'::text\n        WHEN d.scope = 'DOCUMENT_SCOPE_PRIVATE'\n            THEN 'SCOPE_KIND_USER'::text\n    END AS scope_kind,\n    CASE\n        WHEN d.scope = 'DOCUMENT_SCOPE_ORG'\n            THEN ''::text\n        WHEN d.scope = 'DOCUMENT_SCOPE_RESTRICTED'\n            THEN drg.restricted_group_id::text\n        WHEN d.scope = 'DOCUMENT_SCOPE_PRIVATE'\n            THEN d.uploaded_by_user_id::text\n    END AS scope_key\nFROM weave.threads t\nJOIN weave.documents d ON d.id = t.document_id\nLEFT JOIN weave.document_restricted_groups drg\n  ON drg.organization_id = d.organization_id\n AND drg.document_id = d.id\n AND d.scope = 'DOCUMENT_SCOPE_RESTRICTED'\nWHERE t.organization_id = $1\n  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'\n  AND t.embedding IS NOT NULL\n  AND (d.scope <> 'DOCUMENT_SCOPE_RESTRICTED' OR drg.restricted_group_id IS NOT NULL)\nORDER BY t.approved_at DESC, t.id ASC\nLIMIT $3 OFFSET $2";
+export interface ListApprovedThreadsForConsolidationArgs {
+    organizationId: string;
+    pageOffset: string;
+    pageSize: string;
+}
+export interface ListApprovedThreadsForConsolidationRow {
+    id: string;
+    organizationId: string;
+    documentId: string;
+    ingestionRunId: string;
+    text: string;
+    knowledgeType: string;
+    embeddingText: string;
+    approvedAt: Date | null;
+    scopeKind: string | null;
+    scopeKey: string | null;
+}
+export declare function listApprovedThreadsForConsolidation(client: Client, args: ListApprovedThreadsForConsolidationArgs): Promise<ListApprovedThreadsForConsolidationRow[]>;
+export declare const assignThreadsToClusterQuery = "-- name: AssignThreadsToCluster :execrows\nUPDATE weave.threads AS t\nSET cluster_id = cc.id\nFROM weave.concept_clusters cc,\n     weave.documents d\nWHERE t.organization_id = $1\n  AND t.id = ANY($2::uuid[])\n  AND cc.organization_id = t.organization_id\n  AND cc.id = $3\n  AND d.id = t.document_id\n  AND (\n      (cc.scope_kind = 'SCOPE_KIND_ORG'\n          AND cc.scope_key = ''\n          AND d.scope = 'DOCUMENT_SCOPE_ORG')\n      OR (cc.scope_kind = 'SCOPE_KIND_RESTRICTED_GROUP'\n          AND d.scope = 'DOCUMENT_SCOPE_RESTRICTED'\n          AND EXISTS (\n              SELECT 1\n              FROM weave.document_restricted_groups drg\n              WHERE drg.organization_id = d.organization_id\n                AND drg.document_id = d.id\n                AND drg.restricted_group_id::text = cc.scope_key\n          ))\n      OR (cc.scope_kind = 'SCOPE_KIND_USER'\n          AND d.scope = 'DOCUMENT_SCOPE_PRIVATE'\n          AND cc.scope_key = d.uploaded_by_user_id::text)\n  )";
+export interface AssignThreadsToClusterArgs {
+    organizationId: string;
+    threadIds: string[];
+    clusterId: string;
+}
+export declare const clearThreadClusterAssignmentsByOrganizationQuery = "-- name: ClearThreadClusterAssignmentsByOrganization :execrows\nUPDATE weave.threads\nSET cluster_id = NULL\nWHERE organization_id = $1\n  AND cluster_id IS NOT NULL";
+export interface ClearThreadClusterAssignmentsByOrganizationArgs {
+    organizationId: string;
+}
+export declare const clearThreadClusterAssignmentsByDocumentQuery = "-- name: ClearThreadClusterAssignmentsByDocument :execrows\nUPDATE weave.threads\nSET cluster_id = NULL\nWHERE organization_id = $1\n  AND document_id = $2\n  AND cluster_id IS NOT NULL";
+export interface ClearThreadClusterAssignmentsByDocumentArgs {
+    organizationId: string;
+    documentId: string;
+}
+export {};

package/dist/weavesql/weavedb/document_consolidation_sql.js

@@ -0,0 +1,486 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearThreadClusterAssignmentsByDocumentQuery = exports.clearThreadClusterAssignmentsByOrganizationQuery = exports.assignThreadsToClusterQuery = exports.listApprovedThreadsForConsolidationQuery = exports.listConceptClustersByParentAndScopeQuery = exports.listConceptClustersByScopeQuery = exports.getConceptClusterByOrganizationScopeAndIDQuery = exports.upsertConceptClusterQuery = exports.listConsolidationRunsByOrganizationQuery = exports.updateConsolidationRunStateQuery = exports.getConsolidationRunByOrganizationAndIDQuery = exports.createConsolidationRunQuery = void 0;
+exports.createConsolidationRun = createConsolidationRun;
+exports.getConsolidationRunByOrganizationAndID = getConsolidationRunByOrganizationAndID;
+exports.updateConsolidationRunState = updateConsolidationRunState;
+exports.listConsolidationRunsByOrganization = listConsolidationRunsByOrganization;
+exports.upsertConceptCluster = upsertConceptCluster;
+exports.getConceptClusterByOrganizationScopeAndID = getConceptClusterByOrganizationScopeAndID;
+exports.listConceptClustersByScope = listConceptClustersByScope;
+exports.listConceptClustersByParentAndScope = listConceptClustersByParentAndScope;
+exports.listApprovedThreadsForConsolidation = listApprovedThreadsForConsolidation;
+exports.createConsolidationRunQuery = `-- name: CreateConsolidationRun :one
+INSERT INTO weave.consolidation_runs (
+    id,
+    organization_id,
+    status
+) VALUES (
+    $1,
+    $2,
+    $3
+)
+RETURNING
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at`;
+async function createConsolidationRun(client, args) {
+    const result = await client.query({
+        text: exports.createConsolidationRunQuery,
+        values: [args.id, args.organizationId, args.status],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        status: row[2],
+        threadCount: row[3],
+        clusterCount: row[4],
+        hierarchyDepth: row[5],
+        error: row[6],
+        startedAt: row[7],
+        completedAt: row[8]
+    };
+}
+exports.getConsolidationRunByOrganizationAndIDQuery = `-- name: GetConsolidationRunByOrganizationAndID :one
+SELECT
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at
+FROM weave.consolidation_runs
+WHERE organization_id = $1
+  AND id = $2`;
+async function getConsolidationRunByOrganizationAndID(client, args) {
+    const result = await client.query({
+        text: exports.getConsolidationRunByOrganizationAndIDQuery,
+        values: [args.organizationId, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        status: row[2],
+        threadCount: row[3],
+        clusterCount: row[4],
+        hierarchyDepth: row[5],
+        error: row[6],
+        startedAt: row[7],
+        completedAt: row[8]
+    };
+}
+exports.updateConsolidationRunStateQuery = `-- name: UpdateConsolidationRunState :one
+UPDATE weave.consolidation_runs
+SET
+    status = $1,
+    thread_count = $2,
+    cluster_count = $3,
+    hierarchy_depth = $4,
+    error = $5,
+    completed_at = $6
+WHERE id = $7
+  AND organization_id = $8
+RETURNING
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at`;
+async function updateConsolidationRunState(client, args) {
+    const result = await client.query({
+        text: exports.updateConsolidationRunStateQuery,
+        values: [args.status, args.threadCount, args.clusterCount, args.hierarchyDepth, args.error, args.completedAt, args.id, args.organizationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        status: row[2],
+        threadCount: row[3],
+        clusterCount: row[4],
+        hierarchyDepth: row[5],
+        error: row[6],
+        startedAt: row[7],
+        completedAt: row[8]
+    };
+}
+exports.listConsolidationRunsByOrganizationQuery = `-- name: ListConsolidationRunsByOrganization :many
+SELECT
+    id,
+    organization_id,
+    status,
+    thread_count,
+    cluster_count,
+    hierarchy_depth,
+    error,
+    started_at,
+    completed_at
+FROM weave.consolidation_runs
+WHERE organization_id = $1
+ORDER BY started_at DESC
+LIMIT $3 OFFSET $2`;
+async function listConsolidationRunsByOrganization(client, args) {
+    const result = await client.query({
+        text: exports.listConsolidationRunsByOrganizationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            status: row[2],
+            threadCount: row[3],
+            clusterCount: row[4],
+            hierarchyDepth: row[5],
+            error: row[6],
+            startedAt: row[7],
+            completedAt: row[8]
+        };
+    });
+}
+exports.upsertConceptClusterQuery = `-- name: UpsertConceptCluster :one
+INSERT INTO weave.concept_clusters (
+    id,
+    organization_id,
+    scope_kind,
+    scope_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    embedding,
+    centroid,
+    thread_count,
+    consolidation_run_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10::vector,
+    $11::vector,
+    $12,
+    $13
+)
+ON CONFLICT (id) DO UPDATE
+SET
+    name = EXCLUDED.name,
+    description = EXCLUDED.description,
+    scope_kind = EXCLUDED.scope_kind,
+    scope_key = EXCLUDED.scope_key,
+    knowledge_type = EXCLUDED.knowledge_type,
+    level = EXCLUDED.level,
+    parent_id = EXCLUDED.parent_id,
+    embedding = EXCLUDED.embedding,
+    centroid = EXCLUDED.centroid,
+    thread_count = EXCLUDED.thread_count,
+    consolidation_run_id = EXCLUDED.consolidation_run_id,
+    updated_at = now()
+RETURNING
+    id,
+    organization_id,
+    scope_kind,
+    scope_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at`;
+async function upsertConceptCluster(client, args) {
+    const result = await client.query({
+        text: exports.upsertConceptClusterQuery,
+        values: [args.id, args.organizationId, args.scopeKind, args.scopeKey, args.name, args.description, args.knowledgeType, args.level, args.parentId, args.embedding, args.centroid, args.threadCount, args.consolidationRunId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        scopeKind: row[2],
+        scopeKey: row[3],
+        name: row[4],
+        description: row[5],
+        knowledgeType: row[6],
+        level: row[7],
+        parentId: row[8],
+        threadCount: row[9],
+        consolidationRunId: row[10],
+        createdAt: row[11],
+        updatedAt: row[12]
+    };
+}
+exports.getConceptClusterByOrganizationScopeAndIDQuery = `-- name: GetConceptClusterByOrganizationScopeAndID :one
+SELECT
+    id,
+    organization_id,
+    scope_kind,
+    scope_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at
+FROM weave.concept_clusters
+WHERE organization_id = $1
+  AND scope_kind = $2
+  AND scope_key = $3
+  AND id = $4`;
+async function getConceptClusterByOrganizationScopeAndID(client, args) {
+    const result = await client.query({
+        text: exports.getConceptClusterByOrganizationScopeAndIDQuery,
+        values: [args.organizationId, args.scopeKind, args.scopeKey, args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        scopeKind: row[2],
+        scopeKey: row[3],
+        name: row[4],
+        description: row[5],
+        knowledgeType: row[6],
+        level: row[7],
+        parentId: row[8],
+        threadCount: row[9],
+        consolidationRunId: row[10],
+        createdAt: row[11],
+        updatedAt: row[12]
+    };
+}
+exports.listConceptClustersByScopeQuery = `-- name: ListConceptClustersByScope :many
+SELECT
+    id,
+    organization_id,
+    scope_kind,
+    scope_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at
+FROM weave.concept_clusters
+WHERE organization_id = $1
+  AND scope_kind = $2
+  AND scope_key = $3
+  AND ($4 = '' OR knowledge_type = $4)
+  AND ($5 <= 0 OR level <= $5)
+ORDER BY level ASC, updated_at DESC, id ASC`;
+async function listConceptClustersByScope(client, args) {
+    const result = await client.query({
+        text: exports.listConceptClustersByScopeQuery,
+        values: [args.organizationId, args.scopeKind, args.scopeKey, args.knowledgeType, args.maxDepth],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            scopeKind: row[2],
+            scopeKey: row[3],
+            name: row[4],
+            description: row[5],
+            knowledgeType: row[6],
+            level: row[7],
+            parentId: row[8],
+            threadCount: row[9],
+            consolidationRunId: row[10],
+            createdAt: row[11],
+            updatedAt: row[12]
+        };
+    });
+}
+exports.listConceptClustersByParentAndScopeQuery = `-- name: ListConceptClustersByParentAndScope :many
+SELECT
+    id,
+    organization_id,
+    scope_kind,
+    scope_key,
+    name,
+    description,
+    knowledge_type,
+    level,
+    parent_id,
+    thread_count,
+    consolidation_run_id,
+    created_at,
+    updated_at
+FROM weave.concept_clusters
+WHERE organization_id = $1
+  AND scope_kind = $2
+  AND scope_key = $3
+  AND parent_id = $4
+ORDER BY updated_at DESC, id ASC`;
+async function listConceptClustersByParentAndScope(client, args) {
+    const result = await client.query({
+        text: exports.listConceptClustersByParentAndScopeQuery,
+        values: [args.organizationId, args.scopeKind, args.scopeKey, args.parentId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            scopeKind: row[2],
+            scopeKey: row[3],
+            name: row[4],
+            description: row[5],
+            knowledgeType: row[6],
+            level: row[7],
+            parentId: row[8],
+            threadCount: row[9],
+            consolidationRunId: row[10],
+            createdAt: row[11],
+            updatedAt: row[12]
+        };
+    });
+}
+exports.listApprovedThreadsForConsolidationQuery = `-- name: ListApprovedThreadsForConsolidation :many
+SELECT
+    t.id,
+    t.organization_id,
+    t.document_id,
+    t.ingestion_run_id,
+    t.text,
+    t.knowledge_type,
+    t.embedding::text AS embedding_text,
+    t.approved_at,
+    CASE
+        WHEN d.scope = 'DOCUMENT_SCOPE_ORG'
+            THEN 'SCOPE_KIND_ORG'::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+            THEN 'SCOPE_KIND_RESTRICTED_GROUP'::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+            THEN 'SCOPE_KIND_USER'::text
+    END AS scope_kind,
+    CASE
+        WHEN d.scope = 'DOCUMENT_SCOPE_ORG'
+            THEN ''::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+            THEN drg.restricted_group_id::text
+        WHEN d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+            THEN d.uploaded_by_user_id::text
+    END AS scope_key
+FROM weave.threads t
+JOIN weave.documents d ON d.id = t.document_id
+LEFT JOIN weave.document_restricted_groups drg
+  ON drg.organization_id = d.organization_id
+ AND drg.document_id = d.id
+ AND d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+WHERE t.organization_id = $1
+  AND t.retrieval_status = 'THREAD_RETRIEVAL_STATUS_APPROVED'
+  AND t.embedding IS NOT NULL
+  AND (d.scope <> 'DOCUMENT_SCOPE_RESTRICTED' OR drg.restricted_group_id IS NOT NULL)
+ORDER BY t.approved_at DESC, t.id ASC
+LIMIT $3 OFFSET $2`;
+async function listApprovedThreadsForConsolidation(client, args) {
+    const result = await client.query({
+        text: exports.listApprovedThreadsForConsolidationQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            documentId: row[2],
+            ingestionRunId: row[3],
+            text: row[4],
+            knowledgeType: row[5],
+            embeddingText: row[6],
+            approvedAt: row[7],
+            scopeKind: row[8],
+            scopeKey: row[9]
+        };
+    });
+}
+exports.assignThreadsToClusterQuery = `-- name: AssignThreadsToCluster :execrows
+UPDATE weave.threads AS t
+SET cluster_id = cc.id
+FROM weave.concept_clusters cc,
+     weave.documents d
+WHERE t.organization_id = $1
+  AND t.id = ANY($2::uuid[])
+  AND cc.organization_id = t.organization_id
+  AND cc.id = $3
+  AND d.id = t.document_id
+  AND (
+      (cc.scope_kind = 'SCOPE_KIND_ORG'
+          AND cc.scope_key = ''
+          AND d.scope = 'DOCUMENT_SCOPE_ORG')
+      OR (cc.scope_kind = 'SCOPE_KIND_RESTRICTED_GROUP'
+          AND d.scope = 'DOCUMENT_SCOPE_RESTRICTED'
+          AND EXISTS (
+              SELECT 1
+              FROM weave.document_restricted_groups drg
+              WHERE drg.organization_id = d.organization_id
+                AND drg.document_id = d.id
+                AND drg.restricted_group_id::text = cc.scope_key
+          ))
+      OR (cc.scope_kind = 'SCOPE_KIND_USER'
+          AND d.scope = 'DOCUMENT_SCOPE_PRIVATE'
+          AND cc.scope_key = d.uploaded_by_user_id::text)
+  )`;
+exports.clearThreadClusterAssignmentsByOrganizationQuery = `-- name: ClearThreadClusterAssignmentsByOrganization :execrows
+UPDATE weave.threads
+SET cluster_id = NULL
+WHERE organization_id = $1
+  AND cluster_id IS NOT NULL`;
+exports.clearThreadClusterAssignmentsByDocumentQuery = `-- name: ClearThreadClusterAssignmentsByDocument :execrows
+UPDATE weave.threads
+SET cluster_id = NULL
+WHERE organization_id = $1
+  AND document_id = $2
+  AND cluster_id IS NOT NULL`;