@folterung/project-memory 0.1.0

package/packages/server/src/embedding/stub.test.ts

@@ -0,0 +1,28 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { embedText, embedBatch, getVectorSize } from "./stub.js";
+
+describe("embedding stub (server)", () => {
+  it("getVectorSize returns 384", () => {
+    assert.strictEqual(getVectorSize(), 384);
+  });
+
+  it("embedText returns array of length 384", () => {
+    const vec = embedText("hello world");
+    assert.strictEqual(vec.length, 384);
+    assert.ok(vec.every((x) => typeof x === "number" && x >= 0 && x <= 1));
+  });
+
+  it("embedText is deterministic for same input", () => {
+    const a = embedText("same text");
+    const b = embedText("same text");
+    assert.deepStrictEqual(a, b);
+  });
+
+  it("embedBatch returns one vector per text", () => {
+    const batch = embedBatch(["a", "b"]);
+    assert.strictEqual(batch.length, 2);
+    assert.strictEqual(batch[0].length, 384);
+    assert.strictEqual(batch[1].length, 384);
+  });
+});

package/packages/server/src/embedding/stub.ts

@@ -0,0 +1,33 @@
+const VECTOR_SIZE = 384;
+
+function simpleHash(str: string): number {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = (h * 31 + str.charCodeAt(i)) >>> 0;
+  }
+  return h;
+}
+
+/**
+ * Stub embedder: deterministic pseudo-vector from text (same text -> same vector).
+ * V1 local default; replace with real model (e.g. transformers.js) later.
+ */
+export function embedText(text: string): number[] {
+  const vec: number[] = [];
+  const words = text.split(/\s+/).filter(Boolean);
+  for (let i = 0; i < VECTOR_SIZE; i++) {
+    const seed = words[i % words.length]
+      ? simpleHash(words[i % words.length]) + i * 31
+      : i;
+    vec.push(Math.sin(seed) * 0.5 + 0.5);
+  }
+  return vec;
+}
+
+export function embedBatch(texts: string[]): number[][] {
+  return texts.map(embedText);
+}
+
+export function getVectorSize(): number {
+  return VECTOR_SIZE;
+}

package/packages/server/src/index.ts

@@ -0,0 +1,29 @@
+import Fastify from "fastify";
+import { registerHealthRoutes } from "./api/health.js";
+import { registerSearchRoutes } from "./api/search.js";
+import { registerExplainRoutes } from "./api/explain.js";
+import { registerSystemRoutes } from "./api/system.js";
+import { registerRefreshRoutes } from "./api/refresh.js";
+
+const PORT = Number(process.env.MEM_SERVER_PORT) || 31415;
+const CWD = process.env.MEM_CWD || process.cwd();
+const QDRANT_HOST = process.env.MEM_QDRANT_HOST || "127.0.0.1";
+const QDRANT_PORT = Number(process.env.MEM_QDRANT_PORT) || 6333;
+const COLLECTION = process.env.MEM_COLLECTION || "project_memory";
+
+async function main() {
+  const app = Fastify({ logger: true });
+  registerHealthRoutes(app, { cwd: CWD, qdrantHost: QDRANT_HOST, qdrantPort: QDRANT_PORT, collection: COLLECTION });
+  registerSearchRoutes(app, { qdrantHost: QDRANT_HOST, qdrantPort: QDRANT_PORT, collection: COLLECTION });
+  registerExplainRoutes(app, { qdrantHost: QDRANT_HOST, qdrantPort: QDRANT_PORT, collection: COLLECTION });
+  registerSystemRoutes(app, { qdrantHost: QDRANT_HOST, qdrantPort: QDRANT_PORT, collection: COLLECTION });
+  registerRefreshRoutes(app);
+
+  await app.listen({ port: PORT, host: "127.0.0.1" });
+  console.log(`Memory server at http://127.0.0.1:${PORT}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/packages/server/src/qdrant/client.ts

@@ -0,0 +1,92 @@
+import { QdrantClient } from "@qdrant/js-client-rest";
+import { getVectorSize } from "../embedding/stub.js";
+
+const DEFAULT_COLLECTION = "project_memory";
+
+export function createQdrantClient(host: string = "127.0.0.1", port: number = 6333): QdrantClient {
+  return new QdrantClient({ url: `http://${host}:${port}` });
+}
+
+export async function ensureCollection(
+  client: QdrantClient,
+  collectionName: string = DEFAULT_COLLECTION
+): Promise<void> {
+  const size = getVectorSize();
+  try {
+    await client.getCollection(collectionName);
+  } catch {
+    await client.createCollection(collectionName, {
+      vectors: { size, distance: "Cosine" },
+    });
+  }
+}
+
+export interface PointPayload {
+  kind: string;
+  path?: string;
+  text: string;
+  [key: string]: unknown;
+}
+
+export async function upsertPoints(
+  client: QdrantClient,
+  collectionName: string,
+  points: { id: string; vector: number[]; payload: PointPayload }[]
+): Promise<void> {
+  if (points.length === 0) return;
+  await client.upsert(collectionName, {
+    wait: true,
+    points: points.map((p) => ({
+      id: p.id,
+      vector: p.vector,
+      payload: p.payload,
+    })),
+  });
+}
+
+export async function searchPoints(
+  client: QdrantClient,
+  collectionName: string,
+  vector: number[],
+  limit: number = 10,
+  filterKind?: string
+): Promise<{ id: string; score: number; payload: PointPayload }[]> {
+  const filter = filterKind
+    ? { must: [{ key: "kind", match: { value: filterKind } }] }
+    : undefined;
+  return doSearch(client, collectionName, vector, limit, filter);
+}
+
+export async function searchPointsKinds(
+  client: QdrantClient,
+  collectionName: string,
+  vector: number[],
+  limit: number,
+  kinds: string[]
+): Promise<{ id: string; score: number; payload: PointPayload }[]> {
+  const filter =
+    kinds.length > 0
+      ? { should: kinds.map((k) => ({ key: "kind", match: { value: k } })) }
+      : undefined;
+  return doSearch(client, collectionName, vector, limit, filter);
+}
+
+async function doSearch(
+  client: QdrantClient,
+  collectionName: string,
+  vector: number[],
+  limit: number,
+  filter: { must?: unknown[]; should?: unknown[] } | undefined
+): Promise<{ id: string; score: number; payload: PointPayload }[]> {
+  const result = await client.search(collectionName, {
+    vector,
+    limit,
+    with_payload: true,
+    filter,
+  });
+  return result.map((r) => ({
+    id: (r.id as string) ?? String(r.id),
+    score: r.score ?? 0,
+    payload: (r.payload ?? {}) as PointPayload,
+  }));
+}

package/packages/server/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}