refactor(core): remove LanceDB + @xenova/transformers, fix all tests

Part 1.4 of antfly migration:

Removed:
- @lancedb/lancedb and @xenova/transformers from core + dev-agent deps
- LanceDBVectorStore (store.ts) and TransformersEmbedder (embedder.ts)
- Old vector tests (store.test.ts, embedder.test.ts, vector.test.ts)
- LanceDB/@xenova externals from tsup.config.ts

Added:
- VectorStorage mock (__mocks__/index.ts) for tests not needing antfly
- vi.mock for vector module in indexer, subagent, and CLI tests

Fixed:
- All test files that created real VectorStorage now use mock
- Explorer error handling test uses explicit mock instead of close()
- Fetcher test repo name (lytics → prosdevlab)

Result: 1935 tests passing, 0 failures.
No @lancedb or @xenova/transformers references remain in source.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: prosdev

packages/cli/src/commands/commands.test.ts

@@ -2,6 +2,38 @@ import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { Command } from 'commander';
+
+// Mock VectorStorage to avoid needing antfly server
+vi.mock('../../../core/src/vector/index', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    VectorStorage: class MockVectorStorage {
+      async initialize() {}
+      async addDocuments() {}
+      async search() {
+        return [];
+      }
+      async searchByDocumentId() {
+        return [];
+      }
+      async getAll() {
+        return [];
+      }
+      async getDocument() {
+        return null;
+      }
+      async deleteDocuments() {}
+      async clear() {}
+      async getStats() {
+        return { totalDocuments: 0, storageSize: 0, dimension: 384, modelName: 'mock' };
+      }
+      async optimize() {}
+      async close() {}
+    },
+  };
+});
+
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
 import { cleanCommand } from './clean';
 import { indexCommand } from './index';

packages/core/package.json

@@ -38,10 +38,8 @@
   },
   "dependencies": {
     "@antfly/sdk": "0.0.14",
-    "@lancedb/lancedb": "^0.22.3",
     "@prosdevlab/dev-agent-types": "workspace:*",
     "@prosdevlab/kero": "workspace:*",
-    "@xenova/transformers": "^2.17.2",
     "better-sqlite3": "^12.5.0",
     "globby": "^16.0.0",
     "remark": "^15.0.1",

packages/core/src/indexer/__tests__/detailed-stats.integration.test.ts

@@ -1,7 +1,11 @@
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Use mock VectorStorage (no antfly server needed)
+vi.mock('../../vector/index');
+
 import { RepositoryIndexer } from '../index';
 import type { DetailedIndexStats } from '../types';
 

packages/core/src/indexer/__tests__/indexer-edge.test.ts

@@ -2,7 +2,11 @@
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+
+// Use mock VectorStorage (no antfly server needed)
+vi.mock('../../vector/index');
+
 import { RepositoryIndexer } from '../index';
 
 /**

packages/core/src/indexer/__tests__/indexer.test.ts

@@ -1,7 +1,11 @@
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+
+// Use mock VectorStorage (no antfly server needed)
+vi.mock('../../vector/index');
+
 import { RepositoryIndexer } from '../index';
 import type { IndexProgress } from '../types';
 

packages/core/src/vector/__mocks__/index.ts

@@ -0,0 +1,110 @@
+/**
+ * Mock VectorStorage for tests that don't need a real antfly server.
+ *
+ * Used by indexer, subagent, and CLI tests that test their own logic,
+ * not vector storage behavior. The real antfly tests are in antfly-store.test.ts.
+ */
+
+import { vi } from 'vitest';
+
+export { type AntflyStoreConfig, AntflyVectorStore } from '../antfly-store.js';
+// Re-export real types
+export * from '../types.js';
+
+// In-memory document store for mock
+const docs = new Map<string, { text: string; metadata: Record<string, unknown> }>();
+
+export class VectorStorage {
+  private initialized = false;
+
+  constructor(_config: { storePath: string; embeddingModel?: string; dimension?: number }) {
+    // No-op — mock doesn't connect to anything
+  }
+
+  async initialize(_options?: { skipEmbedder?: boolean }): Promise<void> {
+    this.initialized = true;
+  }
+
+  async addDocuments(
+    documents: Array<{ id: string; text: string; metadata: Record<string, unknown> }>
+  ): Promise<void> {
+    for (const doc of documents) {
+      docs.set(doc.id, { text: doc.text, metadata: doc.metadata });
+    }
+  }
+
+  async search(
+    _query: string,
+    options?: { limit?: number; scoreThreshold?: number }
+  ): Promise<Array<{ id: string; score: number; metadata: Record<string, unknown> }>> {
+    const limit = options?.limit ?? 10;
+    const results = Array.from(docs.entries())
+      .slice(0, limit)
+      .map(([id, doc]) => ({
+        id,
+        score: 0.85,
+        metadata: doc.metadata,
+      }));
+    return results;
+  }
+
+  async searchByDocumentId(
+    documentId: string,
+    options?: { limit?: number }
+  ): Promise<Array<{ id: string; score: number; metadata: Record<string, unknown> }>> {
+    return this.search(documentId, options);
+  }
+
+  async getAll(options?: {
+    limit?: number;
+  }): Promise<Array<{ id: string; score: number; metadata: Record<string, unknown> }>> {
+    const limit = options?.limit ?? 10000;
+    return Array.from(docs.entries())
+      .slice(0, limit)
+      .map(([id, doc]) => ({
+        id,
+        score: 1,
+        metadata: doc.metadata,
+      }));
+  }
+
+  async getDocument(
+    id: string
+  ): Promise<{ id: string; text: string; metadata: Record<string, unknown> } | null> {
+    const doc = docs.get(id);
+    if (!doc) return null;
+    return { id, ...doc };
+  }
+
+  async deleteDocuments(ids: string[]): Promise<void> {
+    for (const id of ids) {
+      docs.delete(id);
+    }
+  }
+
+  async clear(): Promise<void> {
+    docs.clear();
+  }
+
+  async getStats(): Promise<{
+    totalDocuments: number;
+    storageSize: number;
+    dimension: number;
+    modelName: string;
+  }> {
+    return {
+      totalDocuments: docs.size,
+      storageSize: 0,
+      dimension: 384,
+      modelName: 'BAAI/bge-small-en-v1.5',
+    };
+  }
+
+  async optimize(): Promise<void> {
+    // no-op
+  }
+
+  async close(): Promise<void> {
+    this.initialized = false;
+  }
+}