@porast1/mcp-cognitive 1.0.0

package/dist/adapters/weaviate.adapter.js

@@ -0,0 +1,678 @@
+import { randomUUID } from 'node:crypto';
+import weaviate from 'weaviate-ts-client';
+import { getAgentProfile } from '../profiles/agent-profiles.js';
+import { checkCitations, overallCitationStatus } from '../utils/citation-checker.js';
+import { checkDecayBatch } from '../utils/decay.js';
+const FACT_CLASS = 'CognitiveFact';
+const DOC_CLASS = 'DddDocument';
+const FACT_TYPES = [
+    'invariant',
+    'policy',
+    'convention',
+    'observation',
+    'ephemeral',
+];
+const MODULES = [
+    'identity',
+    'organization',
+    'platform',
+    'infrastructure',
+    'tooling',
+    'testing',
+    'general',
+];
+const FACT_FIELDS = [
+    'factText',
+    'factType',
+    'module',
+    'confidence',
+    'tags',
+    'citationsJson',
+    'epoch',
+    'status',
+    'createdAt',
+    'updatedAt',
+    'lastRecalled',
+    'recallCount',
+    'supersedes',
+    '_additional { id score }',
+].join(' ');
+const DOC_FIELDS = [
+    'filePath',
+    'module',
+    'content',
+    'checksum',
+    'lastSynced',
+    '_additional { id }',
+].join(' ');
+function parseCitations(raw) {
+    if (!raw)
+        return [];
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+function toFact(record) {
+    return {
+        id: record._additional?.id ?? '',
+        fact: record.factText,
+        type: record.factType,
+        module: record.module,
+        confidence: record.confidence,
+        citations: parseCitations(record.citationsJson),
+        tags: record.tags ?? [],
+        epoch: record.epoch,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        lastRecalled: record.lastRecalled ?? null,
+        recallCount: record.recallCount ?? 0,
+        supersedes: record.supersedes ?? null,
+        status: record.status,
+    };
+}
+function toDocument(record) {
+    return {
+        id: record._additional?.id ?? '',
+        filePath: record.filePath,
+        module: record.module,
+        content: record.content,
+        checksum: record.checksum,
+        lastSynced: record.lastSynced,
+    };
+}
+function validateInput(input) {
+    if (!input.fact || !input.type || !input.module) {
+        throw new Error('Fact input missing required fields');
+    }
+    if (!FACT_TYPES.includes(input.type)) {
+        throw new Error(`Invalid fact type: ${input.type}`);
+    }
+    if (!MODULES.includes(input.module)) {
+        throw new Error(`Invalid module: ${input.module}`);
+    }
+}
+export class WeaviateStore {
+    client;
+    workspaceRoot;
+    constructor(client, workspaceRoot) {
+        this.client = client;
+        this.workspaceRoot = workspaceRoot;
+    }
+    static async create(url, workspaceRoot) {
+        const scheme = url.startsWith('https://') ? 'https' : 'http';
+        const host = url.replace(/^https?:\/\//, '');
+        const client = weaviate.client({ scheme, host });
+        const store = new WeaviateStore(client, workspaceRoot);
+        await store.ensureSchema();
+        return store;
+    }
+    async ensureSchema() {
+        let schema = null;
+        try {
+            const raw = await this.client.schema.getter().do();
+            schema = raw;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Weaviate connection failed: ${message}`);
+        }
+        const existing = new Set(schema?.classes?.map((cls) => cls.class) ?? []);
+        if (!existing.has(FACT_CLASS)) {
+            await this.client.schema
+                .classCreator()
+                .withClass({
+                class: FACT_CLASS,
+                vectorizer: 'text2vec-transformers',
+                moduleConfig: {
+                    'text2vec-transformers': {
+                        vectorizeClassName: false,
+                        vectorizePropertyName: false,
+                    },
+                },
+                properties: [
+                    { name: 'factText', dataType: ['text'] },
+                    { name: 'factType', dataType: ['text'] },
+                    { name: 'module', dataType: ['text'] },
+                    { name: 'confidence', dataType: ['number'] },
+                    { name: 'tags', dataType: ['text'], cardinality: 'many' },
+                    { name: 'citationsJson', dataType: ['text'] },
+                    { name: 'epoch', dataType: ['int'] },
+                    { name: 'status', dataType: ['text'] },
+                    { name: 'createdAt', dataType: ['date'] },
+                    { name: 'updatedAt', dataType: ['date'] },
+                    { name: 'lastRecalled', dataType: ['date'] },
+                    { name: 'recallCount', dataType: ['int'] },
+                    { name: 'supersedes', dataType: ['text'] },
+                    { name: 'documentedIn', dataType: [DOC_CLASS], cardinality: 'many' },
+                ],
+            })
+                .do();
+        }
+        if (!existing.has(DOC_CLASS)) {
+            await this.client.schema
+                .classCreator()
+                .withClass({
+                class: DOC_CLASS,
+                vectorizer: 'text2vec-transformers',
+                moduleConfig: {
+                    'text2vec-transformers': {
+                        vectorizeClassName: false,
+                    },
+                },
+                properties: [
+                    { name: 'filePath', dataType: ['text'] },
+                    { name: 'module', dataType: ['text'] },
+                    { name: 'content', dataType: ['text'] },
+                    { name: 'checksum', dataType: ['text'] },
+                    { name: 'lastSynced', dataType: ['date'] },
+                ],
+            })
+                .do();
+        }
+    }
+    // ─── CRUD ─────────────────────────────────────────────────────────────
+    async store(input) {
+        validateInput(input);
+        const now = new Date().toISOString();
+        const id = randomUUID();
+        await this.client.data
+            .creator()
+            .withClassName(FACT_CLASS)
+            .withId(id)
+            .withProperties({
+            factText: input.fact,
+            factType: input.type,
+            module: input.module,
+            confidence: input.confidence ?? 0.8,
+            tags: input.tags ?? [],
+            citationsJson: JSON.stringify(input.citations ?? []),
+            epoch: input.epoch ?? 3,
+            status: 'active',
+            createdAt: now,
+            updatedAt: now,
+            lastRecalled: null,
+            recallCount: 0,
+            supersedes: input.supersedes ?? null,
+        })
+            .do();
+        if (input.supersedes) {
+            await this.archive(input.supersedes, `Superseded by ${id}`);
+        }
+        const stored = await this.getById(id);
+        if (!stored)
+            throw new Error('Failed to store fact');
+        return stored;
+    }
+    async update(id, patch) {
+        const existing = await this.getById(id);
+        if (!existing)
+            throw new Error(`Fact not found: ${id}`);
+        const now = new Date().toISOString();
+        const updates = { updatedAt: now };
+        if (patch.fact !== undefined)
+            updates['factText'] = patch.fact;
+        if (patch.type !== undefined)
+            updates['factType'] = patch.type;
+        if (patch.module !== undefined)
+            updates['module'] = patch.module;
+        if (patch.confidence !== undefined)
+            updates['confidence'] = patch.confidence;
+        if (patch.citations !== undefined)
+            updates['citationsJson'] = JSON.stringify(patch.citations);
+        if (patch.tags !== undefined)
+            updates['tags'] = patch.tags;
+        if (patch.epoch !== undefined)
+            updates['epoch'] = patch.epoch;
+        if (patch.supersedes !== undefined)
+            updates['supersedes'] = patch.supersedes;
+        await this.client.data
+            .merger()
+            .withClassName(FACT_CLASS)
+            .withId(id)
+            .withProperties(updates)
+            .do();
+        const updated = await this.getById(id);
+        if (!updated)
+            throw new Error('Failed to update fact');
+        return updated;
+    }
+    async archive(id, _reason) {
+        const existing = await this.getById(id);
+        if (!existing)
+            throw new Error(`Fact not found: ${id}`);
+        await this.client.data
+            .merger()
+            .withClassName(FACT_CLASS)
+            .withId(id)
+            .withProperties({
+            status: 'archived',
+            updatedAt: new Date().toISOString(),
+        })
+            .do();
+    }
+    // ─── Search ────────────────────────────────────────────────────────────
+    async recall(query) {
+        const started = Date.now();
+        const profile = query.agent ? getAgentProfile(query.agent) : null;
+        const types = query.types ?? profile?.priorityTypes;
+        const module = query.module ?? profile?.defaultModule;
+        const whereOperands = [
+            { path: ['status'], operator: 'Equal', valueText: 'active' },
+        ];
+        if (module) {
+            whereOperands.push({ path: ['module'], operator: 'Equal', valueText: module });
+        }
+        if (types && types.length > 0) {
+            whereOperands.push({
+                operator: 'Or',
+                operands: types.map((type) => ({
+                    path: ['factType'],
+                    operator: 'Equal',
+                    valueText: type,
+                })),
+            });
+        }
+        if (query.tags && query.tags.length > 0) {
+            whereOperands.push({
+                path: ['tags'],
+                operator: 'ContainsAll',
+                valueTextArray: query.tags,
+            });
+        }
+        if (query.minConfidence !== undefined) {
+            whereOperands.push({
+                path: ['confidence'],
+                operator: 'GreaterThanEqual',
+                valueNumber: query.minConfidence,
+            });
+        }
+        const where = whereOperands.length === 1
+            ? whereOperands[0]
+            : { operator: 'And', operands: whereOperands };
+        const limit = query.limit ?? profile?.maxRecall ?? 10;
+        const trimmedQuery = query.query.trim();
+        let result;
+        if (trimmedQuery.length === 0) {
+            const query = this.client.graphql
+                .get()
+                .withClassName(FACT_CLASS)
+                .withLimit(limit)
+                .withSort([
+                { path: ['confidence'], order: 'desc' },
+                { path: ['updatedAt'], order: 'desc' },
+            ])
+                .withFields(FACT_FIELDS);
+            if (where)
+                query.withWhere(where);
+            result = await query.do();
+        }
+        else {
+            const query = this.client.graphql
+                .get()
+                .withClassName(FACT_CLASS)
+                .withHybrid({ query: trimmedQuery, alpha: 0.5 })
+                .withLimit(limit)
+                .withFields(FACT_FIELDS);
+            if (where)
+                query.withWhere(where);
+            result = await query.do();
+        }
+        const records = result.data?.Get?.[FACT_CLASS] ?? [];
+        const enriched = records.map((record) => ({
+            fact: toFact(record),
+            baseScore: record._additional?.score ?? 0,
+        }));
+        const suppressed = profile && profile.suppressTags.length > 0
+            ? enriched.filter(({ fact }) => !fact.tags.some((tag) => profile.suppressTags.includes(tag)))
+            : enriched;
+        const boosted = suppressed
+            .map(({ fact, baseScore }) => {
+            const boostCount = profile
+                ? fact.tags.filter((tag) => profile.boostTags.includes(tag)).length
+                : 0;
+            return { fact, score: baseScore + boostCount * 0.05 };
+        })
+            .sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            if (b.fact.confidence !== a.fact.confidence) {
+                return b.fact.confidence - a.fact.confidence;
+            }
+            return b.fact.updatedAt.localeCompare(a.fact.updatedAt);
+        })
+            .map((entry) => entry.fact);
+        await this.updateRecallMetadata(boosted);
+        return {
+            facts: boosted,
+            totalMatches: boosted.length,
+            queryTimeMs: Date.now() - started,
+        };
+    }
+    // ─── Maintenance ───────────────────────────────────────────────────────
+    async verify(factId) {
+        const fact = await this.getById(factId);
+        if (!fact)
+            throw new Error(`Fact not found: ${factId}`);
+        const results = checkCitations(fact.citations, this.workspaceRoot);
+        const overall = overallCitationStatus(results);
+        return {
+            factId: fact.id,
+            factSnippet: fact.fact.substring(0, 100),
+            citations: results.map((r) => ({
+                citation: r.citation,
+                status: r.status,
+                ...(r.detail !== undefined ? { detail: r.detail } : {}),
+            })),
+            overallStatus: overall,
+        };
+    }
+    async verifyAll() {
+        const allFacts = await this.exportAll();
+        const results = [];
+        for (const fact of allFacts.filter((f) => f.status === 'active')) {
+            if (fact.citations.length === 0)
+                continue;
+            const citResults = checkCitations(fact.citations, this.workspaceRoot);
+            const overall = overallCitationStatus(citResults);
+            results.push({
+                factId: fact.id,
+                factSnippet: fact.fact.substring(0, 100),
+                citations: citResults.map((r) => ({
+                    citation: r.citation,
+                    status: r.status,
+                    ...(r.detail !== undefined ? { detail: r.detail } : {}),
+                })),
+                overallStatus: overall,
+            });
+        }
+        return results;
+    }
+    async audit() {
+        const allFacts = await this.exportAll();
+        const activeFacts = allFacts.filter((f) => f.status === 'active');
+        const byStatus = { active: 0, stale: 0, archived: 0 };
+        for (const fact of allFacts) {
+            byStatus[fact.status]++;
+        }
+        const byType = {
+            invariant: 0,
+            policy: 0,
+            convention: 0,
+            observation: 0,
+            ephemeral: 0,
+        };
+        for (const fact of allFacts) {
+            byType[fact.type]++;
+        }
+        const byModule = {};
+        for (const fact of allFacts) {
+            byModule[fact.module] = (byModule[fact.module] ?? 0) + 1;
+        }
+        const decayActions = checkDecayBatch(activeFacts);
+        const staleFacts = decayActions
+            .filter((action) => action.action === 'mark-stale')
+            .map((action) => action.fact);
+        const verifications = await this.verifyAll();
+        const brokenCitations = verifications.filter((v) => v.overallStatus === 'broken');
+        const duplicateCandidates = this.findDuplicateCandidates(activeFacts);
+        return {
+            totalFacts: allFacts.length,
+            byStatus,
+            byType,
+            byModule,
+            staleFacts,
+            brokenCitations,
+            duplicateCandidates,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    // ─── Lifecycle ──────────────────────────────────────────────────────────
+    async decayCheck() {
+        const allFacts = await this.exportAll();
+        const candidates = allFacts.filter((fact) => fact.status === 'active' || fact.status === 'stale');
+        const actions = checkDecayBatch(candidates);
+        const now = new Date().toISOString();
+        for (const action of actions) {
+            const status = action.action === 'mark-stale' ? 'stale' : 'archived';
+            await this.client.data
+                .merger()
+                .withClassName(FACT_CLASS)
+                .withId(action.fact.id)
+                .withProperties({ status, updatedAt: now })
+                .do();
+        }
+        return actions.map((action) => action.fact);
+    }
+    async migrate(facts) {
+        const batchSize = 50;
+        const now = new Date().toISOString();
+        for (let i = 0; i < facts.length; i += batchSize) {
+            const batch = facts.slice(i, i + batchSize);
+            const batcher = this.client.batch.objectsBatcher();
+            for (const input of batch) {
+                validateInput(input);
+                batcher.withObject({
+                    class: FACT_CLASS,
+                    id: randomUUID(),
+                    properties: {
+                        factText: input.fact,
+                        factType: input.type,
+                        module: input.module,
+                        confidence: input.confidence ?? 0.8,
+                        tags: input.tags ?? [],
+                        citationsJson: JSON.stringify(input.citations ?? []),
+                        epoch: input.epoch ?? 3,
+                        status: 'active',
+                        createdAt: now,
+                        updatedAt: now,
+                        lastRecalled: null,
+                        recallCount: 0,
+                        supersedes: input.supersedes ?? null,
+                    },
+                });
+            }
+            await batcher.do();
+        }
+    }
+    // ─── Export ────────────────────────────────────────────────────────────
+    async exportAll() {
+        const limit = 100;
+        let offset = 0;
+        const facts = [];
+        while (true) {
+            const result = await this.client.graphql
+                .get()
+                .withClassName(FACT_CLASS)
+                .withLimit(limit)
+                .withOffset(offset)
+                .withFields(FACT_FIELDS)
+                .do();
+            const batch = result.data?.Get?.[FACT_CLASS] ?? [];
+            if (batch.length === 0)
+                break;
+            facts.push(...batch.map(toFact));
+            if (batch.length < limit)
+                break;
+            offset += limit;
+        }
+        return facts;
+    }
+    async count() {
+        try {
+            const result = await this.client.graphql
+                .aggregate()
+                .withClassName(FACT_CLASS)
+                .withFields('meta { count }')
+                .do();
+            const count = result.data?.Aggregate?.[FACT_CLASS]?.[0]?.meta?.count;
+            if (typeof count === 'number')
+                return count;
+        }
+        catch {
+            // fallback to exportAll
+        }
+        const allFacts = await this.exportAll();
+        return allFacts.length;
+    }
+    // ─── Weaviate-specific helpers ─────────────────────────────────────────
+    async upsertDocument(input) {
+        const existing = await this.findDocumentByPath(input.filePath);
+        if (existing) {
+            await this.client.data
+                .merger()
+                .withClassName(DOC_CLASS)
+                .withId(existing.id)
+                .withProperties({
+                module: input.module,
+                content: input.content,
+                checksum: input.checksum,
+                lastSynced: input.lastSynced,
+            })
+                .do();
+            return existing.id;
+        }
+        const id = randomUUID();
+        await this.client.data
+            .creator()
+            .withClassName(DOC_CLASS)
+            .withId(id)
+            .withProperties({
+            filePath: input.filePath,
+            module: input.module,
+            content: input.content,
+            checksum: input.checksum,
+            lastSynced: input.lastSynced,
+        })
+            .do();
+        return id;
+    }
+    async linkToDocument(factId, docPath) {
+        const fact = await this.getById(factId);
+        if (!fact)
+            throw new Error(`Fact not found: ${factId}`);
+        const document = await this.findDocumentByPath(docPath);
+        if (!document) {
+            throw new Error(`Document not found for citation: ${docPath}`);
+        }
+        await this.client.data
+            .referenceCreator()
+            .withClassName(FACT_CLASS)
+            .withId(factId)
+            .withReferenceProperty('documentedIn')
+            .withReference({
+            beacon: `weaviate://localhost/${DOC_CLASS}/${document.id}`,
+        })
+            .do();
+    }
+    async getLinkedDocuments(factId) {
+        const result = await this.client.graphql
+            .get()
+            .withClassName(FACT_CLASS)
+            .withWhere({ path: ['id'], operator: 'Equal', valueText: factId })
+            .withFields(`documentedIn { ${DOC_FIELDS} }`)
+            .withLimit(1)
+            .do();
+        const facts = result.data?.Get?.[FACT_CLASS] ?? [];
+        const docs = facts[0]?.documentedIn ?? [];
+        return docs.map((doc) => toDocument(doc));
+    }
+    async getFactsByDocument(docPath) {
+        const result = await this.client.graphql
+            .get()
+            .withClassName(FACT_CLASS)
+            .withWhere({
+            operator: 'Equal',
+            path: ['documentedIn', DOC_CLASS, 'filePath'],
+            valueText: docPath,
+        })
+            .withFields(FACT_FIELDS)
+            .do();
+        const facts = result.data?.Get?.[FACT_CLASS] ?? [];
+        return facts.map(toFact);
+    }
+    async getDocumentByPath(docPath) {
+        return this.findDocumentByPath(docPath);
+    }
+    // ─── Internal helpers ──────────────────────────────────────────────────
+    async getById(id) {
+        try {
+            const result = await this.client.data
+                .getterById()
+                .withClassName(FACT_CLASS)
+                .withId(id)
+                .do();
+            const record = result?.properties;
+            if (!record)
+                return null;
+            return toFact({ ...record, _additional: { id } });
+        }
+        catch {
+            return null;
+        }
+    }
+    async findDocumentByPath(filePath) {
+        const result = await this.client.graphql
+            .get()
+            .withClassName(DOC_CLASS)
+            .withWhere({ path: ['filePath'], operator: 'Equal', valueText: filePath })
+            .withFields(DOC_FIELDS)
+            .withLimit(1)
+            .do();
+        const docs = result.data?.Get?.[DOC_CLASS] ?? [];
+        if (docs.length === 0)
+            return null;
+        return toDocument(docs[0]);
+    }
+    async updateRecallMetadata(facts) {
+        if (facts.length === 0)
+            return;
+        const now = new Date().toISOString();
+        for (const fact of facts) {
+            await this.client.data
+                .merger()
+                .withClassName(FACT_CLASS)
+                .withId(fact.id)
+                .withProperties({
+                lastRecalled: now,
+                recallCount: (fact.recallCount ?? 0) + 1,
+            })
+                .do();
+        }
+    }
+    findDuplicateCandidates(facts) {
+        const candidates = [];
+        for (let i = 0; i < facts.length; i++) {
+            for (let j = i + 1; j < facts.length; j++) {
+                const first = facts[i];
+                const second = facts[j];
+                if (first.module !== second.module)
+                    continue;
+                const similarity = this.wordOverlap(first.fact, second.fact);
+                if (similarity >= 0.6) {
+                    candidates.push({
+                        a: first.id,
+                        b: second.id,
+                        similarity: `${Math.round(similarity * 100)}%`,
+                    });
+                }
+            }
+        }
+        return candidates;
+    }
+    wordOverlap(textA, textB) {
+        const wordsA = new Set(textA.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+        const wordsB = new Set(textB.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
+        if (wordsA.size === 0 || wordsB.size === 0)
+            return 0;
+        let overlap = 0;
+        for (const word of wordsA) {
+            if (wordsB.has(word))
+                overlap++;
+        }
+        return overlap / Math.max(wordsA.size, wordsB.size);
+    }
+}
+//# sourceMappingURL=weaviate.adapter.js.map