mixgram 1.1.4 → 1.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -9,7 +9,7 @@ MCP memory server compatible with [Engram](https://github.com/gentleman-programm
9
9
  ### Advantages over Engram
10
10
 
11
11
  - **Visible, editable docs** — As you advance with agentic development you see the actual documentation files on disk. You can open them, read them, and edit them manually; the agent’s memory is not hidden in a black box.
12
- - **Versioned** — Memory lives in Markdown under your repo (e.g. `mixgram/<type>/` for project scope) or in a shared home (e.g. `home/memory/` for cross-project). Commit, branch, and diff as with any other docs.
12
+ - **Versioned** — Memory lives in Markdown under your repo (e.g. `docs/<type>/` by default for project scope) or in a shared home (e.g. `home/memory/` for cross-project). Commit, branch, and diff as with any other docs.
13
13
  - **No semantic deps required** — Core experience is text-only (FTS5). No need to install embeddings or vector libs unless you opt in.
14
14
 
15
15
  ---
@@ -57,35 +57,35 @@ Arguments are passed as `--key value`. Booleans use `--flag` or `--no-flag`. Arr
57
57
  | `--embeddings` | `MIXGRAM_EMBEDDINGS_ENABLED` | Enable optional semantic (hybrid) search. |
58
58
  | `--watch` | `MIXGRAM_WATCH` | Watch files and reindex on change. |
59
59
  | `--home <path>` | `MIXGRAM_HOME` | Home memory root (cross-project). |
60
- | `--project-memory <path>` | `MIXGRAM_PROJECT_MEMORY` | Project memory root (default: `./mixgram`, relative to repo). |
60
+ | `--project-memory <path>` | `MIXGRAM_PROJECT_MEMORY` | Project memory root (default: `./docs`, relative to repo). |
61
61
  | `--projects <path>` | `MIXGRAM_PROJECTS` | Projects root (legacy). |
62
62
  | `--sqlite-path <path>` | `MIXGRAM_SQLITE_PATH` | SQLite index path. |
63
63
 
64
64
  **Example — Cursor**
65
65
 
66
- Add to Cursor’s MCP config (or run `mixgram setup cursor`):
66
+ Create `.cursor/mcp.json` in your repo (recommended, and required for Cursor Cloud Agents) or add the same config to `~/.cursor/mcp.json` (or run `mixgram setup cursor`):
67
67
 
68
68
  ```json
69
69
  {
70
70
  "mcpServers": {
71
71
  "mixgram": {
72
72
  "command": "mixgram",
73
- "args": ["mcp", "--project-memory", "${workspaceFolder}/mixgram"]
73
+ "args": ["mcp", "--project-memory", "${workspaceFolder}/docs"]
74
74
  }
75
75
  }
76
76
  }
77
77
  ```
78
78
 
79
- With embeddings and custom paths via args:
79
+ With embeddings and custom paths:
80
80
 
81
81
  ```json
82
82
  "mixgram": {
83
83
  "command": "mixgram",
84
- "args": ["mcp", "--embeddings", "--home", "/data/memory", "--project-memory", "${workspaceFolder}/specs"]
84
+ "args": ["mcp", "--project-memory", "${workspaceFolder}/docs", "--embeddings", "--home", "/data/memory"]
85
85
  }
86
86
  ```
87
87
 
88
- Set `--project-memory` with `${workspaceFolder}` because Cursor supports interpolation in `args`, and that keeps project docs inside the active repo without relying on `cwd`. Or use a config file (see below) and just `"args": ["mcp"]`. Restart Cursor after changing config.
88
+ Restart Cursor after changing config.
89
89
 
90
90
  ---
91
91
 
@@ -115,7 +115,7 @@ Example **`.mixgram/config.json`** (project or home):
115
115
  ```json
116
116
  {
117
117
  "homeMemoryRoot": "~/.mixgram/docs",
118
- "projectMemoryRoot": "./mixgram",
118
+ "projectMemoryRoot": "./docs",
119
119
  "sqlitePath": "~/.mixgram/index.db",
120
120
  "embeddings": {
121
121
  "enabled": true
@@ -128,7 +128,7 @@ Paths in the config file are relative to the config file’s directory (project)
128
128
  | Option | Default | Description |
129
129
  |--------|---------|-------------|
130
130
  | `homeMemoryRoot` | `~/.mixgram/docs` | Cross-project memory (Markdown files). |
131
- | `projectMemoryRoot` | `./mixgram` | Project memory in the current repo (e.g. `mixgram/architecture/`, `mixgram/decisions/`). You can use another folder name, e.g. `./specs` for `specs/architecture/`. |
131
+ | `projectMemoryRoot` | `./docs` | Project memory in the current repo (e.g. `docs/architecture/`, `docs/decisions/`). You can use another folder name, e.g. `./specs` for `specs/architecture/`. |
132
132
  | `sqlitePath` | `~/.mixgram/index.db` | SQLite index (FTS5 + optional vectors). |
133
133
  | `watch` | `true` | Watch files and reindex on change. |
134
134
  | `indexing.reindexOnStartup` | `true` | Full reindex when server starts. |
@@ -143,7 +143,7 @@ import { run } from 'mixgram/src/mcp/server.js';
143
143
 
144
144
  await run({
145
145
  homeMemoryRoot: '/data/memory',
146
- projectMemoryRoot: '/path/to/repo/mixgram',
146
+ projectMemoryRoot: '/path/to/repo/docs',
147
147
  sqlitePath: '/data/.mixgram/index.db',
148
148
  watch: true
149
149
  });
@@ -169,7 +169,7 @@ Core flow: save Markdown-backed documents, search with FTS5, get context.
169
169
  }
170
170
  ```
171
171
 
172
- - **scope** `project` → file under `<repo>/mixgram/<type>/...` (e.g. `mixgram/architecture/`, `mixgram/decisions/`).
172
+ - **scope** `project` → file under `<repo>/docs/<type>/...` (e.g. `docs/architecture/`, `docs/decisions/`).
173
173
  - **scope** `home` → file under `home/memory/...` (cross-project).
174
174
  - Same `topic_key` + scope + project → **update** existing doc; otherwise create.
175
175
 
@@ -238,12 +238,12 @@ Useful after cloning a repo or editing Markdown by hand:
238
238
  { "full": true }
239
239
  ```
240
240
 
241
- - `full: true` — rebuild entire index from `home/**/*.md` and `mixgram/**/*.md` (project memory in repo).
241
+ - `full: true` — rebuild entire index from `home/**/*.md` and `docs/**/*.md` (project memory in repo).
242
242
  - `full: false` (default) — incremental (by mtime).
243
243
 
244
244
  Manual edit example:
245
245
 
246
- 1. Edit a `.md` file under `home/memory` or `mixgram/<type>/` in your repo.
246
+ 1. Edit a `.md` file under `home/memory` or `docs/<type>/` in your repo.
247
247
  2. Call `mem_reindex({ full: true })` (or run with `watch: true` so changes are picked up).
248
248
  3. `mem_search` and `mem_get_observation` reflect the new content.
249
249
 
@@ -280,7 +280,7 @@ When `embeddings.enabled` is `true` and the optional embedding stack is availabl
280
280
 
281
281
  - **Saves** are durable and searchable by text immediately; embeddings are queued and processed in the background.
282
282
  - **Search** becomes **hybrid**: FTS + vector similarity, blended with `search.ftsWeight` and `search.semanticWeight` (e.g. 0.7 and 0.3).
283
- - A **worker** runs in the background and processes the embedding queue (e.g. every 2 seconds).
283
+ - A **worker** runs in a separate process and processes the embedding queue (e.g. every 2 seconds). Query embeddings for hybrid search are also computed in that process via IPC, so the main MCP server never loads `@huggingface/transformers` and is not affected by native/ONNX crashes in the embedding stack.
284
284
 
285
285
  ### Enable embeddings
286
286
 
package/bin/mixgram.js CHANGED
@@ -12,6 +12,10 @@ import { getToolByName, listToolNames, parseToolArgs, formatToolHelp } from '../
12
12
  import fs from 'fs';
13
13
  import path from 'path';
14
14
  import os from 'os';
15
+ import { fileURLToPath } from 'url';
16
+
17
+ const __dirname = path.dirname(fileURLToPath(import.meta.url));
18
+ const PKG = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
15
19
 
16
20
  const SUBCOMMAND = process.argv[2];
17
21
  const ARG = process.argv[3];
@@ -102,8 +106,6 @@ const MIXGRAM_ENTRY = {
102
106
 
103
107
  const CURSOR_MIXGRAM_ENTRY = {
104
108
  command: 'mixgram',
105
- // Cursor supports interpolation in args, so force project-scoped docs into
106
- // the active workspace without relying on cwd resolution.
107
109
  args: ['mcp', '--project-memory', '${workspaceFolder}/docs']
108
110
  };
109
111
 
@@ -216,6 +218,7 @@ Commands:
216
218
  mcp [options] Run the MCP server (stdio). Use this in your client config.
217
219
  setup <client> Register Mixgram with an MCP client.
218
220
  help [tool] Show help; with optional tool name, show options for that tool.
221
+ -v, --version Print version from package and exit.
219
222
  <tool> [options] Run an MCP tool by name. Tools:
220
223
  ${toolLines}
221
224
 
@@ -223,21 +226,20 @@ mcp options (and env / config file):
223
226
  --config <path> Config file (default: ./.mixgram/config.json or ~/.mixgram/config.json)
224
227
  --embeddings Enable semantic search (or embeddings.enabled in config)
225
228
  --watch Watch files and reindex on change
226
- --home <path> Home memory root (default: ./home/memory)
227
- --project-memory <path> Project memory root (default: ./mixgram, relative to repo)
228
- --projects <path> Projects root (default: ./projects)
229
- --sqlite-path <path> SQLite index path (default: ./.mixgram/index.db)
229
+ --home <path> Home memory root (default: ~/.mixgram/docs)
230
+ --project-memory <path> Project memory root (default: ./docs, relative to repo)
231
+ --sqlite-path <path> SQLite index path (default: ~/.mixgram/index.db)
230
232
 
231
233
  Env: MIXGRAM_CONFIG, MIXGRAM_EMBEDDINGS_ENABLED, MIXGRAM_HOME, MIXGRAM_PROJECT_MEMORY,
232
- MIXGRAM_PROJECTS, MIXGRAM_SQLITE_PATH, MIXGRAM_WATCH
234
+ MIXGRAM_SQLITE_PATH, MIXGRAM_WATCH
233
235
 
234
236
  Setup targets:
235
237
  cursor Cursor IDE
236
238
  gemini-cli Gemini CLI
237
239
  codex Codex
238
240
 
239
- Example (Cursor): "mixgram": { "command": "mixgram", "args": ["mcp"] }
240
- With embeddings: "args": ["mcp", "--embeddings"]
241
+ Example (Cursor): "mixgram": { "command": "mixgram", "args": ["mcp", "--project-memory", "${workspaceFolder}/docs"] }
242
+ With embeddings: "args": ["mcp", "--project-memory", "${workspaceFolder}/docs", "--embeddings"]
241
243
  Config file: .mixgram/config.json or ~/.mixgram/config.json
242
244
 
243
245
  npm install -g mixgram
@@ -245,6 +247,11 @@ Config file: .mixgram/config.json or ~/.mixgram/config.json
245
247
  }
246
248
 
247
249
  async function main() {
250
+ if (SUBCOMMAND === '-v' || SUBCOMMAND === '--version') {
251
+ console.log(PKG.version);
252
+ return;
253
+ }
254
+
248
255
  if (SUBCOMMAND === 'mcp') {
249
256
  const { overrides, baseDir, projectBaseDir } = loadCliConfig();
250
257
  await run(overrides, baseDir, projectBaseDir)
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "mixgram",
3
- "version": "1.1.4",
3
+ "version": "1.1.6",
4
4
  "description": "MCP memory server with Markdown source of truth and SQLite FTS5.",
5
5
  "keywords": [
6
6
  "mcp",
package/spec/run-tests.js CHANGED
@@ -22,7 +22,7 @@ const __dirname = path.dirname(__filename);
22
22
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mixgram-test-'));
23
23
  const config = loadConfig({
24
24
  homeMemoryRoot: path.join(tmpDir, 'home', 'memory'),
25
- projectMemoryRoot: path.join(tmpDir, 'mixgram'),
25
+ projectMemoryRoot: path.join(tmpDir, 'docs'),
26
26
  sqlitePath: path.join(tmpDir, '.mixgram', 'index.db')
27
27
  });
28
28
  fs.mkdirSync(path.dirname(config.sqlitePath), { recursive: true });
@@ -57,7 +57,7 @@ function runCliSetupChecks() {
57
57
  const repoRoot = path.dirname(__dirname);
58
58
 
59
59
  if (reporter.VISUAL) {
60
- reporter.startScenario('CLI setup cursor config', 'Verify Cursor setup writes workspace cwd for project-scoped memory.');
60
+ reporter.startScenario('CLI setup cursor config', 'Verify Cursor setup writes project-memory arg for project-scoped memory.');
61
61
  }
62
62
 
63
63
  let p = 0;
@@ -83,9 +83,8 @@ function runCliSetupChecks() {
83
83
  const cursorConfig = JSON.parse(fs.readFileSync(cursorConfigPath, 'utf8'));
84
84
  const entry = cursorConfig?.mcpServers?.mixgram;
85
85
  ok(entry?.command === 'mixgram', 'cursor entry command preserved');
86
- ok(Array.isArray(entry?.args) && entry.args[0] === 'mcp', 'cursor entry args preserved');
87
- ok(entry?.args?.[1] === '--project-memory', 'cursor entry overrides project memory');
88
- ok(entry?.args?.[2] === '${workspaceFolder}/mixgram', 'cursor entry uses workspaceFolder in args');
86
+ const hasProjectMemory = Array.isArray(entry?.args) && entry.args.includes('--project-memory') && entry.args.includes('${workspaceFolder}/docs');
87
+ ok(hasProjectMemory, 'cursor entry uses --project-memory ${workspaceFolder}/docs');
89
88
  } catch (err) {
90
89
  if (reporter.VISUAL) reporter.check('CLI setup cursor config threw', false, err.message);
91
90
  f += 1;
@@ -45,7 +45,7 @@ export const scenarios = [
45
45
  reporter.step('mem_save', { title: decisionSqliteIndex.title, topic_key: decisionSqliteIndex.topic_key }, { id: s1.id, path: s1.path, created: s1.created });
46
46
  ok(s1.success && s1.id && s1.created === true, 'save success');
47
47
  ok(fs.existsSync(s1.path), 'file created');
48
- ok(s1.path.includes('mixgram') || s1.path.replace(/\\/g, '/').includes('mixgram'), 'project doc under mixgram');
48
+ ok(s1.path.includes('docs') || s1.path.replace(/\\/g, '/').includes('docs'), 'project doc under project memory root');
49
49
  ok(path.basename(s1.path) === 'architecture-sqlite-derived-index.md', 'project doc filename omits redundant prefixes');
50
50
 
51
51
  const search1 = await h.mem_search({ query: 'derived SQLite index', project: PROJECT_NAME });
package/src/config.js CHANGED
@@ -55,7 +55,7 @@ function resolvePaths(config, baseDir, projectBaseDir = null) {
55
55
  return {
56
56
  ...config,
57
57
  homeMemoryRoot: path.isAbsolute(homeRoot) ? homeRoot : path.resolve(base, homeRoot),
58
- projectMemoryRoot: path.resolve(projectBase, config.projectMemoryRoot ?? './mixgram'),
58
+ projectMemoryRoot: path.resolve(projectBase, config.projectMemoryRoot ?? './docs'),
59
59
  sqlitePath: path.isAbsolute(sqlite) ? sqlite : path.resolve(base, sqlite)
60
60
  };
61
61
  }
@@ -0,0 +1,79 @@
1
+ /**
2
+ * Standalone process for embedding jobs and query embeddings. Isolates
3
+ * @huggingface/transformers (and any native/ONNX crashes) from the MCP server.
4
+ * Invoked via child_process.fork() with env MIXGRAM_WORKER_CONFIG pointing to
5
+ * a JSON file with the resolved config. Listens for IPC 'embed' to embed query
6
+ * text for hybrid search so the main process never loads transformers.
7
+ */
8
+ import fs from 'fs';
9
+ import path from 'path';
10
+ import { fileURLToPath } from 'url';
11
+
12
+ const __dirname = path.dirname(fileURLToPath(import.meta.url));
13
+ const DEFAULT_POLL_MS = 2000;
14
+
15
+ function loadWorkerConfig() {
16
+ const configPath = process.env.MIXGRAM_WORKER_CONFIG;
17
+ if (!configPath || !fs.existsSync(configPath)) return null;
18
+ const raw = fs.readFileSync(configPath, 'utf8');
19
+ return JSON.parse(raw);
20
+ }
21
+
22
+ let embedderInstance = null;
23
+
24
+ async function getEmbedder(config) {
25
+ if (embedderInstance) return embedderInstance;
26
+ const { getEmbedder: getEmbedderFn } = await import('./embedder.js');
27
+ embedderInstance = await getEmbedderFn(config);
28
+ return embedderInstance;
29
+ }
30
+
31
+ function setupIpc(config) {
32
+ process.on('message', async (msg) => {
33
+ if (msg?.type !== 'embed' || typeof msg.text !== 'string') return;
34
+ try {
35
+ const embedder = await getEmbedder(config);
36
+ if (!embedder) {
37
+ process.send?.({ type: 'embedResult', id: msg.id, err: 'embeddings not available' });
38
+ return;
39
+ }
40
+ const vector = await embedder.embed(msg.text);
41
+ process.send?.({ type: 'embedResult', id: msg.id, vector: Array.from(vector) });
42
+ } catch (err) {
43
+ process.send?.({ type: 'embedResult', id: msg.id, err: String(err?.message ?? err) });
44
+ }
45
+ });
46
+ }
47
+
48
+ async function runLoop(config) {
49
+ const { processNextJob } = await import('./queue.js');
50
+ const pollMs = config?.embeddings?.workerPollMs ?? DEFAULT_POLL_MS;
51
+ const run = async () => {
52
+ try {
53
+ await processNextJob(config);
54
+ } catch (err) {
55
+ if (process.stderr) {
56
+ process.stderr.write(`[mixgram-worker] job error: ${err?.message ?? err}\n`);
57
+ }
58
+ }
59
+ };
60
+ await run();
61
+ setInterval(run, pollMs);
62
+ }
63
+
64
+ function main() {
65
+ const config = loadWorkerConfig();
66
+ if (!config?.embeddings?.enabled) {
67
+ process.exit(0);
68
+ return;
69
+ }
70
+ if (process.send) setupIpc(config);
71
+ runLoop(config).catch((err) => {
72
+ if (process.stderr) {
73
+ process.stderr.write(`[mixgram-worker] fatal: ${err?.message ?? err}\n`);
74
+ }
75
+ process.exit(1);
76
+ });
77
+ }
78
+
79
+ main();
@@ -118,24 +118,44 @@ function search(config, options = {}) {
118
118
  async function hybridSearch(config, { query, scopeMode, project, limit, ftsRows }) {
119
119
  const ftsWeight = config.search?.ftsWeight ?? 0.7;
120
120
  const semanticWeight = config.search?.semanticWeight ?? 0.3;
121
- let embedder;
121
+ let queryEmbedding;
122
+ if (typeof config.getQueryEmbedding === 'function') {
123
+ try {
124
+ queryEmbedding = await config.getQueryEmbedding(query);
125
+ } catch {
126
+ return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
127
+ }
128
+ } else {
129
+ let embedder;
130
+ try {
131
+ const [{ getEmbedder }, { getVectorStore }] = await Promise.all([
132
+ import('../embeddings/embedder.js'),
133
+ import('../embeddings/vectorStore.js')
134
+ ]);
135
+ embedder = await getEmbedder(config);
136
+ if (!embedder) {
137
+ return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
138
+ }
139
+ queryEmbedding = await embedder.embed(query);
140
+ } catch {
141
+ return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
142
+ }
143
+ }
144
+ if (!queryEmbedding) {
145
+ return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
146
+ }
122
147
  let vectorStore;
123
148
  try {
124
- const [{ getEmbedder }, { getVectorStore }] = await Promise.all([
125
- import('../embeddings/embedder.js'),
126
- import('../embeddings/vectorStore.js')
127
- ]);
128
- embedder = await getEmbedder(config);
149
+ const { getVectorStore } = await import('../embeddings/vectorStore.js');
129
150
  vectorStore = await getVectorStore(config);
130
151
  } catch {
131
152
  return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
132
153
  }
133
- if (!embedder || !vectorStore) {
154
+ if (!vectorStore) {
134
155
  return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
135
156
  }
136
157
  let semanticHits;
137
158
  try {
138
- const queryEmbedding = await embedder.embed(query);
139
159
  semanticHits = await vectorStore.search(config, queryEmbedding, Math.max(limit * 2, 30));
140
160
  } catch {
141
161
  return ftsRows.slice(0, limit).map(({ _rank, ...r }) => r);
package/src/mcp/server.js CHANGED
@@ -1,9 +1,49 @@
1
+ import { fork } from 'child_process';
2
+ import fs from 'fs';
3
+ import path from 'path';
4
+ import os from 'os';
5
+ import { randomUUID } from 'crypto';
6
+ import { fileURLToPath } from 'url';
1
7
  import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
2
8
  import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
3
9
  import { loadConfig } from '../config.js';
4
10
  import { createToolHandlers } from './tools.js';
5
11
  import { getToolDefinitions } from './tool-registry.js';
6
12
 
13
+ const __dirname = path.dirname(fileURLToPath(import.meta.url));
14
+ let embeddingWorkerChild = null;
15
+ let embeddingWorkerConfigPath = null;
16
+
17
+ const EMBED_TIMEOUT_MS = 60000;
18
+
19
+ function makeQueryEmbedder(child) {
20
+ return function getQueryEmbedding(text) {
21
+ if (!child?.connected) return Promise.resolve(null);
22
+ const id = randomUUID();
23
+ return new Promise((resolve, reject) => {
24
+ const timeout = setTimeout(() => {
25
+ cleanup();
26
+ reject(new Error('embedding timeout'));
27
+ }, EMBED_TIMEOUT_MS);
28
+ const onMessage = (msg) => {
29
+ if (msg?.type !== 'embedResult' || msg.id !== id) return;
30
+ cleanup();
31
+ if (msg.err) {
32
+ reject(new Error(msg.err));
33
+ return;
34
+ }
35
+ resolve(msg.vector ? new Float32Array(msg.vector) : null);
36
+ };
37
+ const cleanup = () => {
38
+ clearTimeout(timeout);
39
+ child.off('message', onMessage);
40
+ };
41
+ child.on('message', onMessage);
42
+ child.send({ type: 'embed', id, text });
43
+ });
44
+ };
45
+ }
46
+
7
47
  function createServer(configOverrides = {}, baseDir = null, projectBaseDir = null) {
8
48
  const config = loadConfig(configOverrides, baseDir, projectBaseDir);
9
49
  const mcpServer = new McpServer(
@@ -59,8 +99,33 @@ async function run(configOverrides = {}, baseDir = null, projectBaseDir = null)
59
99
  }
60
100
  if (config.embeddings?.enabled) {
61
101
  try {
62
- const { startWorker } = await import('../core/embeddings/worker.js');
63
- startWorker(config);
102
+ embeddingWorkerConfigPath = path.join(
103
+ os.tmpdir(),
104
+ `mixgram-worker-config-${process.pid}-${Date.now()}.json`
105
+ );
106
+ fs.writeFileSync(embeddingWorkerConfigPath, JSON.stringify(config), 'utf8');
107
+ const workerPath = path.join(__dirname, '..', 'core', 'embeddings', 'worker-process.js');
108
+ embeddingWorkerChild = fork(workerPath, [], {
109
+ stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
110
+ env: { ...process.env, MIXGRAM_WORKER_CONFIG: embeddingWorkerConfigPath }
111
+ });
112
+ config.getQueryEmbedding = makeQueryEmbedder(embeddingWorkerChild);
113
+ embeddingWorkerChild.on('exit', (code, signal) => {
114
+ if (code !== 0 && code != null && process.stderr) {
115
+ process.stderr.write(`[mixgram] embeddings worker exited: code=${code} signal=${signal}\n`);
116
+ }
117
+ config.getQueryEmbedding = null;
118
+ if (embeddingWorkerConfigPath && fs.existsSync(embeddingWorkerConfigPath)) {
119
+ try { fs.unlinkSync(embeddingWorkerConfigPath); } catch (_) {}
120
+ embeddingWorkerConfigPath = null;
121
+ }
122
+ });
123
+ process.on('exit', () => {
124
+ if (embeddingWorkerChild) embeddingWorkerChild.kill();
125
+ if (embeddingWorkerConfigPath && fs.existsSync(embeddingWorkerConfigPath)) {
126
+ try { fs.unlinkSync(embeddingWorkerConfigPath); } catch (_) {}
127
+ }
128
+ });
64
129
  } catch (err) {
65
130
  if (typeof process !== 'undefined' && process.stderr) {
66
131
  process.stderr.write(`[mixgram] embeddings worker start failed: ${err?.message ?? err}\n`);