argustack 0.2.0 → 0.3.1

package/dist/adapters/postgres/storage.js

@@ -1,648 +1,132 @@
 import { createPool } from './connection.js';
 import { ensureSchema } from './schema.js';
-import { adfToMarkdown } from '../../workspace/adf.js';
 import { PostgresCodeMetaStore } from './code-meta.js';
+import { PostgresIssueStorage } from './storage-issues.js';
+import { PostgresCommitStorage } from './storage-commits.js';
+import { PostgresPullRequestStorage } from './storage-prs.js';
+import { PostgresSearchStorage } from './storage-search.js';
+import { PostgresDbSchemaStorage } from './storage-dbschema.js';
+import { PostgresGraphStorage } from './storage-graph.js';
+import { PostgresQueryStorage } from './storage-query.js';
 /**
- * PostgreSQL adapter — implements IStorage + ICodeMetaStore (via base class).
+ * PostgreSQL adapter — implements {@link IStorage} + {@link ICodeMetaStore}
+ * (via the {@link PostgresCodeMetaStore} base class).
  *
- * Uses UPSERT (ON CONFLICT) so re-pulling is safe and idempotent.
+ * Composition over inheritance: this class is a thin orchestrator that
+ * holds one specialized storage module per aggregate
+ * (`storage-issues`, `storage-commits`, etc.) and delegates every
+ * `IStorage` method to the matching module. Each module owns the SQL
+ * for one table family and stays under the 900-line architectural
+ * file-size cap.
+ *
+ * Every public method is scoped by `workspaceId` as the first
+ * parameter and binds it to the tenant `workspace_id` column.
  */
 export class PostgresStorage extends PostgresCodeMetaStore {
     name = 'PostgreSQL';
+    issues;
+    commits;
+    prs;
+    search;
+    dbSchema;
+    graph;
+    query;
     constructor(config) {
         super(createPool(config));
+        this.issues = new PostgresIssueStorage(this.pool);
+        this.commits = new PostgresCommitStorage(this.pool);
+        this.prs = new PostgresPullRequestStorage(this.pool);
+        this.search = new PostgresSearchStorage(this.pool);
+        this.dbSchema = new PostgresDbSchemaStorage(this.pool);
+        this.graph = new PostgresGraphStorage(this.pool);
+        this.query = new PostgresQueryStorage(this.pool);
     }
     async initialize() {
         await ensureSchema(this.pool);
     }
-    async saveBatch(batch) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            for (const issue of batch.issues) {
-                await client.query(`INSERT INTO issues (
-            issue_key, issue_id, project_key, summary, description,
-            issue_type, status, status_category, priority, resolution,
-            assignee, assignee_id, reporter, reporter_id, created, updated, resolved,
-            due_date, labels, components, fix_versions, parent_key,
-            sprint, story_points, original_estimate, remaining_estimate, time_spent,
-            custom_fields, raw_json, source, pulled_at,
-            search_vector
-          ) VALUES (
-            $1, $2, $3, $4, $5,
-            $6, $7, $8, $9, $10,
-            $11, $12, $13, $14, $15, $16, $17,
-            $18, $19, $20, $21, $22,
-            $23, $24, $25, $26, $27,
-            $28, $29, $30, NOW(),
-            to_tsvector('english', $31)
-          )
-          ON CONFLICT (issue_key) DO UPDATE SET
-            issue_id = EXCLUDED.issue_id,
-            project_key = EXCLUDED.project_key,
-            summary = EXCLUDED.summary,
-            description = EXCLUDED.description,
-            issue_type = EXCLUDED.issue_type,
-            status = EXCLUDED.status,
-            status_category = EXCLUDED.status_category,
-            priority = EXCLUDED.priority,
-            resolution = EXCLUDED.resolution,
-            assignee = EXCLUDED.assignee,
-            assignee_id = EXCLUDED.assignee_id,
-            reporter = EXCLUDED.reporter,
-            reporter_id = EXCLUDED.reporter_id,
-            created = EXCLUDED.created,
-            updated = EXCLUDED.updated,
-            resolved = EXCLUDED.resolved,
-            due_date = EXCLUDED.due_date,
-            labels = EXCLUDED.labels,
-            components = EXCLUDED.components,
-            fix_versions = EXCLUDED.fix_versions,
-            parent_key = EXCLUDED.parent_key,
-            sprint = EXCLUDED.sprint,
-            story_points = EXCLUDED.story_points,
-            original_estimate = EXCLUDED.original_estimate,
-            remaining_estimate = EXCLUDED.remaining_estimate,
-            time_spent = EXCLUDED.time_spent,
-            custom_fields = EXCLUDED.custom_fields,
-            raw_json = EXCLUDED.raw_json,
-            source = EXCLUDED.source,
-            pulled_at = NOW(),
-            search_vector = to_tsvector('english', coalesce(EXCLUDED.summary, '') || ' ' || coalesce(EXCLUDED.description, ''))
-          `, [
-                    issue.key, issue.id, issue.projectKey, issue.summary, normalizeDescription(issue.description),
-                    issue.issueType, issue.status, issue.statusCategory, issue.priority, issue.resolution,
-                    issue.assignee, issue.assigneeId, issue.reporter, issue.reporterId, issue.created, issue.updated, issue.resolved,
-                    issue.dueDate, issue.labels, issue.components, issue.fixVersions, issue.parentKey,
-                    issue.sprint, issue.storyPoints, issue.originalEstimate, issue.remainingEstimate, issue.timeSpent,
-                    JSON.stringify(issue.customFields), JSON.stringify(issue.rawJson), issue.source ?? 'jira',
-                    [issue.summary, normalizeDescription(issue.description)].filter(Boolean).join(' '),
-                ]);
-            }
-            const issueKeys = batch.issues.map((i) => i.key);
-            if (issueKeys.length > 0) {
-                const keysParam = issueKeys.map((_, i) => `$${i + 1}`).join(',');
-                await client.query(`DELETE FROM issue_comments WHERE issue_key IN (${keysParam})`, issueKeys);
-                await client.query(`DELETE FROM issue_changelogs WHERE issue_key IN (${keysParam})`, issueKeys);
-                await client.query(`DELETE FROM issue_worklogs WHERE issue_key IN (${keysParam})`, issueKeys);
-                await client.query(`DELETE FROM issue_links WHERE source_key IN (${keysParam})`, issueKeys);
-            }
-            for (const c of batch.comments) {
-                await client.query(`INSERT INTO issue_comments (issue_key, comment_id, author, body, created, updated)
-           VALUES ($1, $2, $3, $4, $5, $6)`, [c.issueKey, c.commentId, c.author, c.body, c.created, c.updated]);
-            }
-            for (const ch of batch.changelogs) {
-                await client.query(`INSERT INTO issue_changelogs (issue_key, author, field, from_value, to_value, changed_at)
-           VALUES ($1, $2, $3, $4, $5, $6)`, [ch.issueKey, ch.author, ch.field, ch.fromValue, ch.toValue, ch.changedAt]);
-            }
-            for (const w of batch.worklogs) {
-                await client.query(`INSERT INTO issue_worklogs (issue_key, author, time_spent, time_spent_seconds, comment, started)
-           VALUES ($1, $2, $3, $4, $5, $6)`, [w.issueKey, w.author, w.timeSpent, w.timeSpentSeconds, w.comment, w.started]);
-            }
-            for (const l of batch.links) {
-                await client.query(`INSERT INTO issue_links (source_key, target_key, link_type, direction)
-           VALUES ($1, $2, $3, $4)`, [l.sourceKey, l.targetKey, l.linkType, l.direction]);
-            }
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            client.release();
-        }
+    async saveBatch(workspaceId, batch) {
+        await this.issues.saveBatch(workspaceId, batch);
     }
-    async saveCommitBatch(batch) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            for (const commit of batch.commits) {
-                await client.query(`INSERT INTO commits (hash, message, author, email, committed_at, parents, repo_path, pulled_at, search_vector)
-           VALUES ($1, $2, $3, $4, $5, $6::text[], $7, NOW(),
-             to_tsvector('english', $8)
-           )
-           ON CONFLICT (hash) DO UPDATE SET
-             message = EXCLUDED.message,
-             author = EXCLUDED.author,
-             email = EXCLUDED.email,
-             committed_at = EXCLUDED.committed_at,
-             parents = EXCLUDED.parents,
-             repo_path = EXCLUDED.repo_path,
-             pulled_at = NOW(),
-             search_vector = to_tsvector('english', coalesce(EXCLUDED.message, '') || ' ' || coalesce(EXCLUDED.author, ''))`, [commit.hash, commit.message, commit.author, commit.email, commit.committedAt, commit.parents, commit.repoPath, `${commit.message || ''} ${commit.author || ''}`]);
-            }
-            const hashes = batch.commits.map((c) => c.hash);
-            if (hashes.length > 0) {
-                const hashesParam = hashes.map((_, i) => `$${i + 1}`).join(',');
-                await client.query(`DELETE FROM commit_files WHERE commit_hash IN (${hashesParam})`, hashes);
-                await client.query(`DELETE FROM commit_issue_refs WHERE commit_hash IN (${hashesParam})`, hashes);
-            }
-            for (const file of batch.files) {
-                await client.query(`INSERT INTO commit_files (commit_hash, file_path, status, additions, deletions)
-           VALUES ($1, $2, $3, $4, $5)`, [file.commitHash, file.filePath, file.status, file.additions, file.deletions]);
-            }
-            for (const ref of batch.issueRefs) {
-                await client.query(`INSERT INTO commit_issue_refs (commit_hash, issue_key)
-           VALUES ($1, $2)
-           ON CONFLICT DO NOTHING`, [ref.commitHash, ref.issueKey]);
-            }
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            client.release();
-        }
+    async getLastUpdated(workspaceId, projectKey) {
+        return this.issues.getLastUpdated(workspaceId, projectKey);
     }
-    async getLastCommitDate(repoPath) {
-        const result = await this.pool.query(`SELECT MAX(committed_at) as last_date FROM commits WHERE repo_path = $1`, [repoPath]);
-        return result.rows[0]?.last_date ?? null;
+    async getLocalIssues(workspaceId) {
+        return this.issues.getLocalIssues(workspaceId);
     }
-    async getLastUpdated(projectKey) {
-        const result = await this.pool.query(`SELECT MAX(updated) as last_updated FROM issues WHERE project_key = $1`, [projectKey]);
-        const raw = result.rows[0]?.last_updated;
-        if (!raw) {
-            return null;
-        }
-        return new Date(raw).toISOString();
+    async updateIssueSource(workspaceId, issueKey, source) {
+        await this.issues.updateIssueSource(workspaceId, issueKey, source);
     }
-    async saveGitHubBatch(batch) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            for (const pr of batch.pullRequests) {
-                await client.query(`INSERT INTO pull_requests (
-            number, repo_full_name, title, body, state, author,
-            created_at, updated_at, merged_at, closed_at,
-            merge_commit_sha, head_ref, base_ref,
-            labels, reviewers, additions, deletions, changed_files,
-            raw_json, pulled_at, search_vector
-          ) VALUES (
-            $1, $2, $3, $4, $5, $6,
-            $7, $8, $9, $10,
-            $11, $12, $13,
-            $14::text[], $15::text[], $16, $17, $18,
-            $19, NOW(),
-            to_tsvector('english', $20)
-          )
-          ON CONFLICT (repo_full_name, number) DO UPDATE SET
-            title = EXCLUDED.title,
-            body = EXCLUDED.body,
-            state = EXCLUDED.state,
-            author = EXCLUDED.author,
-            created_at = EXCLUDED.created_at,
-            updated_at = EXCLUDED.updated_at,
-            merged_at = EXCLUDED.merged_at,
-            closed_at = EXCLUDED.closed_at,
-            merge_commit_sha = EXCLUDED.merge_commit_sha,
-            head_ref = EXCLUDED.head_ref,
-            base_ref = EXCLUDED.base_ref,
-            labels = EXCLUDED.labels,
-            reviewers = EXCLUDED.reviewers,
-            additions = EXCLUDED.additions,
-            deletions = EXCLUDED.deletions,
-            changed_files = EXCLUDED.changed_files,
-            raw_json = EXCLUDED.raw_json,
-            pulled_at = NOW(),
-            search_vector = to_tsvector('english', coalesce(EXCLUDED.title, '') || ' ' || coalesce(EXCLUDED.body, ''))`, [
-                    pr.number, pr.repoFullName, pr.title, pr.body, pr.state, pr.author,
-                    pr.createdAt, pr.updatedAt, pr.mergedAt, pr.closedAt,
-                    pr.mergeCommitSha, pr.headRef, pr.baseRef,
-                    pr.labels, pr.reviewers, pr.additions, pr.deletions, pr.changedFiles,
-                    JSON.stringify(pr.rawJson),
-                    [pr.title, pr.body].filter(Boolean).join(' '),
-                ]);
-            }
-            const prNumbers = batch.pullRequests.map((p) => p.number);
-            const repoName = batch.pullRequests[0]?.repoFullName;
-            if (prNumbers.length > 0 && repoName) {
-                const prParams = prNumbers.map((_, i) => `$${i + 2}`).join(',');
-                await client.query(`DELETE FROM pr_reviews WHERE repo_full_name = $1 AND pr_number IN (${prParams})`, [repoName, ...prNumbers]);
-                await client.query(`DELETE FROM pr_comments WHERE repo_full_name = $1 AND pr_number IN (${prParams})`, [repoName, ...prNumbers]);
-                await client.query(`DELETE FROM pr_files WHERE repo_full_name = $1 AND pr_number IN (${prParams})`, [repoName, ...prNumbers]);
-                await client.query(`DELETE FROM pr_issue_refs WHERE repo_full_name = $1 AND pr_number IN (${prParams})`, [repoName, ...prNumbers]);
-            }
-            for (const r of batch.reviews) {
-                await client.query(`INSERT INTO pr_reviews (pr_number, repo_full_name, review_id, reviewer, state, body, submitted_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7)`, [r.prNumber, r.repoFullName, r.reviewId, r.reviewer, r.state, r.body, r.submittedAt]);
-            }
-            for (const c of batch.comments) {
-                await client.query(`INSERT INTO pr_comments (pr_number, repo_full_name, comment_id, author, body, path, line, created_at, updated_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [c.prNumber, c.repoFullName, c.commentId, c.author, c.body, c.path, c.line, c.createdAt, c.updatedAt]);
-            }
-            for (const f of batch.files) {
-                await client.query(`INSERT INTO pr_files (pr_number, repo_full_name, file_path, status, additions, deletions)
-           VALUES ($1, $2, $3, $4, $5, $6)`, [f.prNumber, f.repoFullName, f.filePath, f.status, f.additions, f.deletions]);
-            }
-            for (const ref of batch.issueRefs) {
-                await client.query(`INSERT INTO pr_issue_refs (pr_number, repo_full_name, issue_key)
-           VALUES ($1, $2, $3)
-           ON CONFLICT DO NOTHING`, [ref.prNumber, ref.repoFullName, ref.issueKey]);
-            }
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            client.release();
-        }
+    async updateIssueFields(workspaceId, issueKey, fields) {
+        await this.issues.updateIssueFields(workspaceId, issueKey, fields);
     }
-    async saveReleases(releases) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            for (const rel of releases) {
-                await client.query(`INSERT INTO releases (
-            id, repo_full_name, tag_name, name, body, author,
-            draft, prerelease, created_at, published_at,
-            raw_json, pulled_at, search_vector
-          ) VALUES (
-            $1, $2, $3, $4, $5, $6,
-            $7, $8, $9, $10,
-            $11, NOW(),
-            to_tsvector('english', $12)
-          )
-          ON CONFLICT (repo_full_name, id) DO UPDATE SET
-            tag_name = EXCLUDED.tag_name,
-            name = EXCLUDED.name,
-            body = EXCLUDED.body,
-            author = EXCLUDED.author,
-            draft = EXCLUDED.draft,
-            prerelease = EXCLUDED.prerelease,
-            created_at = EXCLUDED.created_at,
-            published_at = EXCLUDED.published_at,
-            raw_json = EXCLUDED.raw_json,
-            pulled_at = NOW(),
-            search_vector = to_tsvector('english', coalesce(EXCLUDED.name, '') || ' ' || coalesce(EXCLUDED.body, '') || ' ' || coalesce(EXCLUDED.tag_name, ''))`, [
-                    rel.id, rel.repoFullName, rel.tagName, rel.name, rel.body, rel.author,
-                    rel.draft, rel.prerelease, rel.createdAt, rel.publishedAt,
-                    JSON.stringify(rel.rawJson),
-                    [rel.name, rel.body, rel.tagName].filter(Boolean).join(' '),
-                ]);
-            }
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            client.release();
-        }
+    async getModifiedIssues(workspaceId) {
+        return this.issues.getModifiedIssues(workspaceId);
     }
-    async getLastPrUpdated(repoFullName) {
-        const result = await this.pool.query(`SELECT MAX(updated_at) as last_updated FROM pull_requests WHERE repo_full_name = $1`, [repoFullName]);
-        return result.rows[0]?.last_updated ?? null;
+    async clearModifiedFlag(workspaceId, issueKey) {
+        await this.issues.clearModifiedFlag(workspaceId, issueKey);
     }
-    async getUnembeddedIssueKeys(limit) {
-        const result = await this.pool.query(`SELECT issue_key FROM issues WHERE embedding IS NULL ORDER BY updated DESC NULLS LAST LIMIT $1`, [limit]);
-        return result.rows.map((r) => r.issue_key);
+    async saveCommitBatch(workspaceId, batch) {
+        await this.commits.saveCommitBatch(workspaceId, batch);
     }
-    async saveEmbedding(issueKey, vector) {
-        await this.pool.query(`UPDATE issues SET embedding = $1 WHERE issue_key = $2`, [`[${vector.join(',')}]`, issueKey]);
+    async getLastCommitDate(workspaceId, repoPath) {
+        return this.commits.getLastCommitDate(workspaceId, repoPath);
     }
-    async semanticSearch(vector, limit, threshold) {
-        const vectorStr = `[${vector.join(',')}]`;
-        const thresholdClause = threshold !== undefined
-            ? `AND 1 - (embedding <=> $1::vector) >= ${String(threshold)}`
-            : '';
-        const result = await this.pool.query(`SELECT issue_key, 1 - (embedding <=> $1::vector) AS similarity
-       FROM issues
-       WHERE embedding IS NOT NULL ${thresholdClause}
-       ORDER BY embedding <=> $1::vector
-       LIMIT $2`, [vectorStr, limit]);
-        return result.rows.map((r) => ({
-            issueKey: r.issue_key,
-            similarity: r.similarity,
-        }));
+    async saveGitHubBatch(workspaceId, batch) {
+        await this.prs.saveGitHubBatch(workspaceId, batch);
     }
-    async hybridSearch(query, vector, limit, threshold) {
-        const k = 60;
-        const maxPerSource = limit * 2;
-        const minSimilarity = threshold ?? 0.5;
-        if (!vector) {
-            const result = await this.pool.query(`SELECT issue_key,
-                1.0 / (${String(k)} + ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_vector, plainto_tsquery('english', $1)) DESC)) AS score,
-                true AS in_text,
-                false AS in_vector
-         FROM issues
-         WHERE search_vector @@ plainto_tsquery('english', $1)
-         ORDER BY score DESC
-         LIMIT $2`, [query, limit]);
-            return result.rows.map((r) => ({
-                issueKey: r.issue_key,
-                score: r.score,
-                source: 'text',
-            }));
-        }
-        const vectorStr = `[${vector.join(',')}]`;
-        const result = await this.pool.query(`WITH text_search AS (
-         SELECT issue_key, ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_vector, plainto_tsquery('english', $1)) DESC) AS rank
-         FROM issues
-         WHERE search_vector @@ plainto_tsquery('english', $1)
-         LIMIT $3
-       ),
-       vector_search AS (
-         SELECT issue_key, ROW_NUMBER() OVER (ORDER BY embedding <=> $2::vector) AS rank
-         FROM issues
-         WHERE embedding IS NOT NULL
-           AND 1 - (embedding <=> $2::vector) >= ${String(minSimilarity)}
-         LIMIT $3
-       )
-       SELECT COALESCE(t.issue_key, v.issue_key) AS issue_key,
-              1.0 / (${String(k)} + COALESCE(t.rank, 1000)) + 1.0 / (${String(k)} + COALESCE(v.rank, 1000)) AS score,
-              t.issue_key IS NOT NULL AS in_text,
-              v.issue_key IS NOT NULL AS in_vector
-       FROM text_search t
-       FULL OUTER JOIN vector_search v ON t.issue_key = v.issue_key
-       ORDER BY score DESC
-       LIMIT $4`, [query, vectorStr, maxPerSource, limit]);
-        return result.rows.map((r) => {
-            let source;
-            if (r.in_text && r.in_vector) {
-                source = 'both';
-            }
-            else if (r.in_text) {
-                source = 'text';
-            }
-            else {
-                source = 'semantic';
-            }
-            return { issueKey: r.issue_key, score: r.score, source };
-        });
+    async saveReleases(workspaceId, releases) {
+        await this.prs.saveReleases(workspaceId, releases);
     }
-    async query(sql, params) {
-        const result = await this.pool.query(sql, params);
-        return { rows: result.rows };
+    async getLastPrUpdated(workspaceId, repoFullName) {
+        return this.prs.getLastPrUpdated(workspaceId, repoFullName);
     }
-    async saveDbSchemaBatch(batch, sourceName) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            for (const table of batch.tables) {
-                await client.query(`INSERT INTO db_tables (source_name, table_schema, table_name, row_count, size_bytes)
-           VALUES ($1, $2, $3, $4, $5)
-           ON CONFLICT (source_name, table_schema, table_name) DO UPDATE SET
-             row_count = EXCLUDED.row_count,
-             size_bytes = EXCLUDED.size_bytes,
-             pulled_at = NOW()`, [sourceName, table.schema, table.name, table.rowCount, table.sizeBytes]);
-                for (const col of table.columns) {
-                    await client.query(`INSERT INTO db_columns (source_name, table_schema, table_name, column_name, data_type, is_nullable, default_value, is_primary_key, ordinal_position)
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-             ON CONFLICT (source_name, table_schema, table_name, column_name) DO UPDATE SET
-               data_type = EXCLUDED.data_type,
-               is_nullable = EXCLUDED.is_nullable,
-               default_value = EXCLUDED.default_value,
-               is_primary_key = EXCLUDED.is_primary_key,
-               ordinal_position = EXCLUDED.ordinal_position`, [sourceName, table.schema, table.name, col.name, col.dataType, col.nullable, col.defaultValue, col.isPrimaryKey, col.ordinalPosition]);
-                }
-            }
-            for (const fk of batch.foreignKeys) {
-                await client.query(`INSERT INTO db_foreign_keys (source_name, table_name, column_name, referenced_table, referenced_column)
-           VALUES ($1, $2, $3, $4, $5)
-           ON CONFLICT (source_name, table_name, column_name, referenced_table, referenced_column) DO NOTHING`, [sourceName, fk.tableName, fk.columnName, fk.referencedTable, fk.referencedColumn]);
-            }
-            for (const idx of batch.indexes) {
-                await client.query(`INSERT INTO db_indexes (source_name, table_name, index_name, columns, is_unique, is_primary)
-           VALUES ($1, $2, $3, $4, $5, $6)
-           ON CONFLICT (source_name, table_name, index_name) DO UPDATE SET
-             columns = EXCLUDED.columns,
-             is_unique = EXCLUDED.is_unique,
-             is_primary = EXCLUDED.is_primary`, [sourceName, idx.tableName, idx.indexName, idx.columns, idx.isUnique, idx.isPrimary]);
-            }
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            client.release();
-        }
+    async getUnembeddedIssueKeys(workspaceId, limit) {
+        return this.search.getUnembeddedIssueKeys(workspaceId, limit);
     }
-    async deleteDbSchema(sourceName) {
-        await this.pool.query('DELETE FROM db_indexes WHERE source_name = $1', [sourceName]);
-        await this.pool.query('DELETE FROM db_foreign_keys WHERE source_name = $1', [sourceName]);
-        await this.pool.query('DELETE FROM db_columns WHERE source_name = $1', [sourceName]);
-        await this.pool.query('DELETE FROM db_tables WHERE source_name = $1', [sourceName]);
+    async saveEmbedding(workspaceId, issueKey, vector) {
+        await this.search.saveEmbedding(workspaceId, issueKey, vector);
     }
-    async getLocalIssues() {
-        const result = await this.pool.query(`SELECT * FROM issues WHERE source = 'local' ORDER BY created`);
-        return result.rows.map((row) => this.mapRowToIssue(row));
+    async semanticSearch(workspaceId, vector, limit, threshold) {
+        return this.search.semanticSearch(workspaceId, vector, limit, threshold);
     }
-    async updateIssueSource(issueKey, source) {
-        await this.pool.query(`UPDATE issues SET source = $2 WHERE issue_key = $1`, [issueKey, source]);
+    async hybridSearch(workspaceId, query, vector, limit, threshold) {
+        return this.search.hybridSearch(workspaceId, query, vector, limit, threshold);
     }
-    async updateIssueFields(issueKey, fields) {
-        const fieldMap = {};
-        if (fields.summary !== undefined) {
-            fieldMap['summary'] = fields.summary;
-        }
-        if (fields.description !== undefined) {
-            fieldMap['description'] = fields.description;
-        }
-        if (fields.status !== undefined) {
-            fieldMap['status'] = fields.status;
-        }
-        if (fields.priority !== undefined) {
-            fieldMap['priority'] = fields.priority;
-        }
-        if (fields.assignee !== undefined) {
-            fieldMap['assignee'] = fields.assignee;
-        }
-        if (fields.labels !== undefined) {
-            fieldMap['labels'] = fields.labels;
-        }
-        if (fields.components !== undefined) {
-            fieldMap['components'] = fields.components;
-        }
-        if (fields.storyPoints !== undefined) {
-            fieldMap['story_points'] = fields.storyPoints;
-        }
-        const keys = Object.keys(fieldMap);
-        if (keys.length === 0) {
-            return;
-        }
-        const setClauses = keys.map((col, i) => `${col} = $${String(i + 2)}`);
-        setClauses.push('locally_modified = true', 'modified_at = NOW()');
-        setClauses.push(`modified_fields = $${String(keys.length + 2)}`);
-        const values = keys.map((col) => fieldMap[col]);
-        values.push(keys);
-        const sql = `UPDATE issues SET ${setClauses.join(', ')} WHERE issue_key = $1`;
-        const result = await this.pool.query(sql, [issueKey, ...values]);
-        if (result.rowCount === 0) {
-            throw new Error(`Issue ${issueKey} not found in local database`);
-        }
+    async saveDbSchemaBatch(workspaceId, batch, sourceName) {
+        await this.dbSchema.saveDbSchemaBatch(workspaceId, batch, sourceName);
     }
-    async getModifiedIssues() {
-        const result = await this.pool.query(`SELECT * FROM issues WHERE locally_modified = true ORDER BY modified_at`);
-        return result.rows.map((row) => {
-            const r = row;
-            return {
-                ...this.mapRowToIssue(r),
-                modifiedFields: r['modified_fields'] ?? [],
-            };
-        });
+    async deleteDbSchema(workspaceId, sourceName) {
+        await this.dbSchema.deleteDbSchema(workspaceId, sourceName);
     }
-    mapRowToIssue(row) {
-        const str = (key) => typeof row[key] === 'string' ? row[key] : '';
-        const strNull = (key) => typeof row[key] === 'string' ? row[key] : null;
-        const numNull = (key) => typeof row[key] === 'number' ? row[key] : null;
-        const arr = (key) => Array.isArray(row[key]) ? row[key] : [];
-        return {
-            key: str('issue_key'),
-            id: str('issue_id'),
-            projectKey: str('project_key'),
-            summary: str('summary'),
-            description: strNull('description'),
-            issueType: strNull('issue_type'),
-            status: strNull('status'),
-            statusCategory: strNull('status_category'),
-            priority: strNull('priority'),
-            resolution: strNull('resolution'),
-            assignee: strNull('assignee'),
-            assigneeId: strNull('assignee_id'),
-            reporter: strNull('reporter'),
-            reporterId: strNull('reporter_id'),
-            created: strNull('created'),
-            updated: strNull('updated'),
-            resolved: strNull('resolved'),
-            dueDate: strNull('due_date'),
-            labels: arr('labels'),
-            components: arr('components'),
-            fixVersions: arr('fix_versions'),
-            parentKey: strNull('parent_key'),
-            sprint: strNull('sprint'),
-            storyPoints: numNull('story_points'),
-            originalEstimate: numNull('original_estimate'),
-            remainingEstimate: numNull('remaining_estimate'),
-            timeSpent: numNull('time_spent'),
-            customFields: row['custom_fields'] ?? {},
-            rawJson: row['raw_json'] ?? {},
-            source: row['source'] ?? 'jira',
-        };
+    async saveGraphEntities(workspaceId, entities) {
+        await this.graph.saveGraphEntities(workspaceId, entities);
     }
-    async clearModifiedFlag(issueKey) {
-        await this.pool.query(`UPDATE issues SET locally_modified = false, modified_at = NULL WHERE issue_key = $1`, [issueKey]);
+    async saveGraphRelationships(workspaceId, rels) {
+        await this.graph.saveGraphRelationships(workspaceId, rels);
     }
-    async saveGraphEntities(entities) {
-        for (const entity of entities) {
-            await this.pool.query(`INSERT INTO graph_entities (name, type, properties)
-         VALUES ($1, $2, $3)
-         ON CONFLICT (name, type) DO UPDATE SET properties = EXCLUDED.properties`, [entity.name, entity.type, JSON.stringify(entity.properties)]);
-        }
+    async saveGraphObservation(workspaceId, entityId, content, author) {
+        await this.graph.saveGraphObservation(workspaceId, entityId, content, author);
     }
-    async saveGraphRelationships(rels) {
-        for (const rel of rels) {
-            await this.pool.query(`INSERT INTO graph_relationships (source_id, target_id, type, weight, source, properties)
-         VALUES ($1, $2, $3, $4, $5, $6)
-         ON CONFLICT (source_id, target_id, type) DO UPDATE SET weight = EXCLUDED.weight, properties = EXCLUDED.properties`, [rel.sourceId, rel.targetId, rel.type, rel.weight, rel.source, JSON.stringify(rel.properties)]);
-        }
+    async getObservations(workspaceId, entityId) {
+        return this.graph.getObservations(workspaceId, entityId);
     }
-    async saveGraphObservation(entityId, content, author) {
-        await this.pool.query(`INSERT INTO graph_observations (entity_id, content, author) VALUES ($1, $2, $3)`, [entityId, content, author]);
+    async queryGraph(workspaceId, entityName, depth) {
+        return this.graph.queryGraph(workspaceId, entityName, depth);
     }
-    async getObservations(entityId) {
-        const result = await this.pool.query(`SELECT id, entity_id, content, author, created_at FROM graph_observations WHERE entity_id = $1 ORDER BY created_at`, [entityId]);
-        return result.rows.map((r) => ({
-            id: r['id'],
-            entityId: r['entity_id'],
-            content: r['content'],
-            author: r['author'],
-            createdAt: r['created_at'],
-        }));
+    async getGraphStats(workspaceId) {
+        return this.graph.getGraphStats(workspaceId);
     }
-    async queryGraph(entityName, depth) {
-        const result = await this.pool.query(`WITH RECURSIVE graph_walk AS (
-        SELECT id, name, type, properties, 0 as depth
-        FROM graph_entities WHERE name ILIKE $1
-        UNION
-        SELECT e.id, e.name, e.type, e.properties, gw.depth + 1
-        FROM graph_walk gw
-        JOIN graph_relationships r ON r.source_id = gw.id OR r.target_id = gw.id
-        JOIN graph_entities e ON e.id = CASE WHEN r.source_id = gw.id THEN r.target_id ELSE r.source_id END
-        WHERE gw.depth < $2
-      )
-      SELECT DISTINCT id, name, type, properties FROM graph_walk LIMIT 200`, [`%${entityName}%`, depth]);
-        const entityIds = result.rows.map((r) => r['id']);
-        const entities = result.rows.map((r) => ({
-            id: r['id'],
-            name: r['name'],
-            type: r['type'],
-            properties: r['properties'],
-        }));
-        let relationships = [];
-        let observations = [];
-        if (entityIds.length > 0) {
-            const idList = entityIds.map((_, i) => `$${String(i + 1)}`).join(',');
-            const relResult = await this.pool.query(`SELECT id, source_id, target_id, type, weight, source, properties
-         FROM graph_relationships WHERE source_id IN (${idList}) OR target_id IN (${idList})`, entityIds);
-            relationships = relResult.rows.map((r) => ({
-                id: r['id'],
-                sourceId: r['source_id'],
-                targetId: r['target_id'],
-                type: r['type'],
-                weight: Number(r['weight']),
-                source: r['source'],
-                properties: r['properties'],
-            }));
-            const obsResult = await this.pool.query(`SELECT id, entity_id, content, author, created_at
-         FROM graph_observations WHERE entity_id IN (${idList})`, entityIds);
-            observations = obsResult.rows.map((r) => ({
-                id: r['id'],
-                entityId: r['entity_id'],
-                content: r['content'],
-                author: r['author'],
-                createdAt: r['created_at'],
-            }));
-        }
-        return { entities, relationships, observations };
+    async clearGraph(workspaceId) {
+        await this.graph.clearGraph(workspaceId);
     }
-    async getGraphStats() {
-        const entityResult = await this.pool.query(`SELECT type, COUNT(*) as cnt FROM graph_entities GROUP BY type`);
-        const relResult = await this.pool.query(`SELECT type, COUNT(*) as cnt FROM graph_relationships GROUP BY type`);
-        const obsResult = await this.pool.query(`SELECT COUNT(*) as cnt FROM graph_observations`);
-        const byEntityType = {};
-        let entityCount = 0;
-        for (const row of entityResult.rows) {
-            const count = Number(row['cnt']);
-            byEntityType[row['type']] = count;
-            entityCount += count;
-        }
-        const byRelationshipType = {};
-        let relationshipCount = 0;
-        for (const row of relResult.rows) {
-            const count = Number(row['cnt']);
-            byRelationshipType[row['type']] = count;
-            relationshipCount += count;
-        }
-        const firstRow = obsResult.rows[0];
-        const observationCount = Number(firstRow?.['cnt'] ?? 0);
-        return { entityCount, relationshipCount, observationCount, byEntityType, byRelationshipType };
+    async queryForWorkspace(workspaceId, sql, params) {
+        return this.query.queryForWorkspace(workspaceId, sql, params);
     }
-    async clearGraph() {
-        await this.pool.query(`DELETE FROM graph_relationships WHERE source IN ('structural', 'auto')`);
-        await this.pool.query(`DELETE FROM graph_entities WHERE id NOT IN (
-        SELECT DISTINCT source_id FROM graph_relationships
-        UNION SELECT DISTINCT target_id FROM graph_relationships
-      ) AND id NOT IN (SELECT DISTINCT entity_id FROM graph_observations)`);
+    async rawQuery(sql, params) {
+        return this.query.rawQuery(sql, params);
     }
     async close() {
         await this.pool.end();
     }
 }
-function normalizeDescription(desc) {
-    if (!desc) {
-        return desc;
-    }
-    if (desc.startsWith('{"type":"doc"')) {
-        return adfToMarkdown(desc);
-    }
-    return desc;
-}
 //# sourceMappingURL=storage.js.map