@hasna/brains 0.0.2 → 0.0.4

package/dist/index.js

@@ -9403,6 +9403,32 @@ class ThinkerLabsProvider {
     return cancelJob(jobId);
   }
 }
+// src/lib/package-metadata.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_VERSION = "0.0.0";
+var cachedVersion;
+function getPackageJsonPath() {
+  return resolve(dirname2(fileURLToPath(import.meta.url)), "../../package.json");
+}
+function getPackageVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  const packageJsonPath = getPackageJsonPath();
+  if (!existsSync(packageJsonPath)) {
+    cachedVersion = DEFAULT_VERSION;
+    return cachedVersion;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    cachedVersion = typeof packageJson.version === "string" ? packageJson.version : DEFAULT_VERSION;
+  } catch {
+    cachedVersion = DEFAULT_VERSION;
+  }
+  return cachedVersion;
+}
 export {
   uploadTrainingFile,
   uploadTrainingData,
@@ -9412,6 +9438,7 @@ export {
   listModels,
   listFineTunedModels,
   getStatus,
+  getPackageVersion,
   getFineTuneStatus,
   getDb,
   fineTunedModels,

package/dist/lib/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./providers/index.js";
+export * from "./package-metadata.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/dist/lib/package-metadata.d.ts

@@ -0,0 +1,2 @@
+export declare function getPackageVersion(): string;
+//# sourceMappingURL=package-metadata.d.ts.map

package/dist/lib/package-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-metadata.d.ts","sourceRoot":"","sources":["../../src/lib/package-metadata.ts"],"names":[],"mappings":"AAYA,wBAAgB,iBAAiB,IAAI,MAAM,CAmB1C"}

package/dist/mcp/index.d.ts

@@ -1,2 +1,75 @@
-export {};
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+export declare const MCP_SERVER_INFO: {
+    readonly name: "brains";
+    readonly version: string;
+};
+export declare function createMcpServer(): Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>;
+export declare function startMcpServer(transport?: StdioServerTransport): Promise<Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AA8BjF,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4X9B;AAED,wBAAsB,cAAc,CAAC,SAAS,uBAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1E"}

package/dist/mcp/index.js

@@ -33,8 +33,8 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 import { homedir as homedir3 } from "os";
 
 // node_modules/drizzle-orm/entity.js
@@ -9525,6 +9525,33 @@ async function gatherFromTodos(options = {}) {
   }
 }
 
+// src/lib/package-metadata.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_VERSION = "0.0.0";
+var cachedVersion;
+function getPackageJsonPath() {
+  return resolve(dirname2(fileURLToPath(import.meta.url)), "../../package.json");
+}
+function getPackageVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  const packageJsonPath = getPackageJsonPath();
+  if (!existsSync(packageJsonPath)) {
+    cachedVersion = DEFAULT_VERSION;
+    return cachedVersion;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    cachedVersion = typeof packageJson.version === "string" ? packageJson.version : DEFAULT_VERSION;
+  } catch {
+    cachedVersion = DEFAULT_VERSION;
+  }
+  return cachedVersion;
+}
+
 // src/mcp/index.ts
 function getProvider(provider) {
   if (provider === "openai")
@@ -9534,312 +9561,330 @@ function getProvider(provider) {
   throw new Error(`Unknown provider: ${provider}`);
 }
 function defaultOutputDir() {
-  return resolve(homedir3(), ".brains", "datasets");
-}
-var server = new Server({ name: "brains", version: "0.0.1" }, { capabilities: { tools: {} } });
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: "list_models",
-      description: "List all fine-tuned models tracked in the local DB",
-      inputSchema: {
-        type: "object",
-        properties: {},
-        required: []
-      }
-    },
-    {
-      name: "get_model",
-      description: "Get details for a specific fine-tuned model",
-      inputSchema: {
-        type: "object",
-        properties: {
-          model_id: { type: "string", description: "Model ID" }
-        },
-        required: ["model_id"]
-      }
-    },
-    {
-      name: "start_finetune",
-      description: "Upload a training file and start a fine-tuning job",
-      inputSchema: {
-        type: "object",
-        properties: {
-          provider: {
-            type: "string",
-            enum: ["openai", "thinker-labs"],
-            description: "Provider to use for fine-tuning"
+  return resolve2(homedir3(), ".brains", "datasets");
+}
+var MCP_SERVER_INFO = {
+  name: "brains",
+  version: getPackageVersion()
+};
+function createMcpServer() {
+  const server = new Server(MCP_SERVER_INFO, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "list_models",
+        description: "List all fine-tuned models tracked in the local DB",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "get_model",
+        description: "Get details for a specific fine-tuned model",
+        inputSchema: {
+          type: "object",
+          properties: {
+            model_id: { type: "string", description: "Model ID" }
           },
-          base_model: {
-            type: "string",
-            description: "Base model identifier (e.g. gpt-4o-mini-2024-07-18)"
+          required: ["model_id"]
+        }
+      },
+      {
+        name: "start_finetune",
+        description: "Upload a training file and start a fine-tuning job",
+        inputSchema: {
+          type: "object",
+          properties: {
+            provider: {
+              type: "string",
+              enum: ["openai", "thinker-labs"],
+              description: "Provider to use for fine-tuning"
+            },
+            base_model: {
+              type: "string",
+              description: "Base model identifier (e.g. gpt-4o-mini-2024-07-18)"
+            },
+            dataset_path: {
+              type: "string",
+              description: "Absolute path to the JSONL training file"
+            },
+            name: {
+              type: "string",
+              description: "Optional friendly name for this model"
+            }
           },
-          dataset_path: {
-            type: "string",
-            description: "Absolute path to the JSONL training file"
+          required: ["provider", "base_model", "dataset_path"]
+        }
+      },
+      {
+        name: "get_finetune_status",
+        description: "Check the status of a fine-tuning job",
+        inputSchema: {
+          type: "object",
+          properties: {
+            job_id: { type: "string", description: "Fine-tune job ID" },
+            provider: {
+              type: "string",
+              enum: ["openai", "thinker-labs"],
+              description: "Provider that owns the job"
+            }
           },
-          name: {
-            type: "string",
-            description: "Optional friendly name for this model"
-          }
-        },
-        required: ["provider", "base_model", "dataset_path"]
-      }
-    },
-    {
-      name: "get_finetune_status",
-      description: "Check the status of a fine-tuning job",
-      inputSchema: {
-        type: "object",
-        properties: {
-          job_id: { type: "string", description: "Fine-tune job ID" },
-          provider: {
-            type: "string",
-            enum: ["openai", "thinker-labs"],
-            description: "Provider that owns the job"
-          }
-        },
-        required: ["job_id", "provider"]
-      }
-    },
-    {
-      name: "gather_training_data",
-      description: "Gather training data from ecosystem sources (todos, mementos, conversations, sessions)",
-      inputSchema: {
-        type: "object",
-        properties: {
-          sources: {
-            type: "array",
-            items: { type: "string" },
-            description: "Sources to gather from: todos, mementos, conversations, sessions"
+          required: ["job_id", "provider"]
+        }
+      },
+      {
+        name: "gather_training_data",
+        description: "Gather training data from ecosystem sources (todos, mementos, conversations, sessions)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sources: {
+              type: "array",
+              items: { type: "string" },
+              description: "Sources to gather from: todos, mementos, conversations, sessions"
+            },
+            limit: {
+              type: "number",
+              description: "Max examples per source (default: unlimited)"
+            },
+            output_dir: {
+              type: "string",
+              description: "Directory to write JSONL files (default: ~/.brains/datasets/)"
+            }
           },
-          limit: {
-            type: "number",
-            description: "Max examples per source (default: unlimited)"
+          required: ["sources"]
+        }
+      },
+      {
+        name: "preview_training_data",
+        description: "Preview examples from a JSONL training file",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Absolute path to the JSONL file to preview"
+            },
+            limit: {
+              type: "number",
+              description: "Max number of examples to return (default: 5)"
+            }
           },
-          output_dir: {
-            type: "string",
-            description: "Directory to write JSONL files (default: ~/.brains/datasets/)"
-          }
-        },
-        required: ["sources"]
+          required: ["file_path"]
+        }
       }
-    },
-    {
-      name: "preview_training_data",
-      description: "Preview examples from a JSONL training file",
-      inputSchema: {
-        type: "object",
-        properties: {
-          file_path: {
-            type: "string",
-            description: "Absolute path to the JSONL file to preview"
-          },
-          limit: {
-            type: "number",
-            description: "Max number of examples to return (default: 5)"
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request2) => {
+    const { name, arguments: args } = request2.params;
+    try {
+      switch (name) {
+        case "list_models": {
+          const db = getDb();
+          const models = await db.select({
+            id: fineTunedModels.id,
+            name: fineTunedModels.name,
+            provider: fineTunedModels.provider,
+            status: fineTunedModels.status,
+            base_model: fineTunedModels.baseModel,
+            created_at: fineTunedModels.createdAt
+          }).from(fineTunedModels).orderBy(fineTunedModels.createdAt);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(models, null, 2)
+              }
+            ]
+          };
+        }
+        case "get_model": {
+          const { model_id } = args;
+          const db = getDb();
+          const results = await db.select().from(fineTunedModels).where(eq(fineTunedModels.id, model_id));
+          if (results.length === 0) {
+            return {
+              content: [{ type: "text", text: `Model not found: ${model_id}` }],
+              isError: true
+            };
           }
-        },
-        required: ["file_path"]
-      }
-    }
-  ]
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request2) => {
-  const { name, arguments: args } = request2.params;
-  try {
-    switch (name) {
-      case "list_models": {
-        const db = getDb();
-        const models = await db.select({
-          id: fineTunedModels.id,
-          name: fineTunedModels.name,
-          provider: fineTunedModels.provider,
-          status: fineTunedModels.status,
-          base_model: fineTunedModels.baseModel,
-          created_at: fineTunedModels.createdAt
-        }).from(fineTunedModels).orderBy(fineTunedModels.createdAt);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(models, null, 2)
-            }
-          ]
-        };
-      }
-      case "get_model": {
-        const { model_id } = args;
-        const db = getDb();
-        const results = await db.select().from(fineTunedModels).where(eq(fineTunedModels.id, model_id));
-        if (results.length === 0) {
           return {
-            content: [{ type: "text", text: `Model not found: ${model_id}` }],
-            isError: true
+            content: [
+              { type: "text", text: JSON.stringify(results[0], null, 2) }
+            ]
           };
         }
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(results[0], null, 2) }
-          ]
-        };
-      }
-      case "start_finetune": {
-        const {
-          provider,
-          base_model,
-          dataset_path,
-          name: modelName
-        } = args;
-        const resolvedPath = resolve(dataset_path);
-        if (!existsSync(resolvedPath)) {
+        case "start_finetune": {
+          const {
+            provider,
+            base_model,
+            dataset_path,
+            name: modelName
+          } = args;
+          const resolvedPath = resolve2(dataset_path);
+          if (!existsSync2(resolvedPath)) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Dataset file not found: ${resolvedPath}`
+                }
+              ],
+              isError: true
+            };
+          }
+          const p = getProvider(provider);
+          const { fileId } = await p.uploadTrainingFile(resolvedPath);
+          const { jobId, status } = await p.createFineTuneJob(fileId, base_model, modelName);
+          const db = getDb();
+          const now = Date.now();
+          const id = `${provider}-${jobId}`;
+          await db.insert(fineTunedModels).values({
+            id,
+            name: modelName ?? `${base_model}-finetune-${now}`,
+            provider,
+            baseModel: base_model,
+            status: "pending",
+            fineTuneJobId: jobId,
+            createdAt: now,
+            updatedAt: now
+          });
           return {
             content: [
               {
                 type: "text",
-                text: `Dataset file not found: ${resolvedPath}`
+                text: JSON.stringify({ job_id: jobId, status, model_db_id: id }, null, 2)
               }
-            ],
-            isError: true
+            ]
           };
         }
-        const p = getProvider(provider);
-        const { fileId } = await p.uploadTrainingFile(resolvedPath);
-        const { jobId, status } = await p.createFineTuneJob(fileId, base_model, modelName);
-        const db = getDb();
-        const now = Date.now();
-        const id = `${provider}-${jobId}`;
-        await db.insert(fineTunedModels).values({
-          id,
-          name: modelName ?? `${base_model}-finetune-${now}`,
-          provider,
-          baseModel: base_model,
-          status: "pending",
-          fineTuneJobId: jobId,
-          createdAt: now,
-          updatedAt: now
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ job_id: jobId, status, model_db_id: id }, null, 2)
-            }
-          ]
-        };
-      }
-      case "get_finetune_status": {
-        const { job_id, provider } = args;
-        const p = getProvider(provider);
-        const result = await p.getFineTuneStatus(job_id);
-        const db = getDb();
-        const dbId = `${provider}-${job_id}`;
-        const existing = await db.select().from(fineTunedModels).where(eq(fineTunedModels.id, dbId));
-        if (existing.length > 0) {
-          const mappedStatus = (() => {
-            if (result.status === "succeeded")
-              return "succeeded";
-            if (result.status === "failed")
-              return "failed";
-            if (result.status === "cancelled")
-              return "cancelled";
-            if (result.status === "running")
-              return "running";
-            return "pending";
-          })();
-          await db.update(fineTunedModels).set({
-            status: mappedStatus,
-            updatedAt: Date.now()
-          }).where(eq(fineTunedModels.id, dbId));
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                job_id: result.jobId,
-                status: result.status,
-                model_id: result.fineTunedModel,
-                error: result.error
-              }, null, 2)
-            }
-          ]
-        };
-      }
-      case "gather_training_data": {
-        const {
-          sources,
-          limit: limit2,
-          output_dir
-        } = args;
-        const { mkdirSync: mkdirSync2, writeFileSync } = await import("fs");
-        const { join: join3 } = await import("path");
-        const outDir = output_dir ?? defaultOutputDir();
-        mkdirSync2(outDir, { recursive: true });
-        const datasets = [];
-        let totalExamples = 0;
-        for (const source of sources) {
-          let examples = [];
-          if (source === "todos") {
-            const result = await gatherFromTodos({ limit: limit2 });
-            examples = result.examples;
-          } else {
-            examples = [];
+        case "get_finetune_status": {
+          const { job_id, provider } = args;
+          const p = getProvider(provider);
+          const result = await p.getFineTuneStatus(job_id);
+          const db = getDb();
+          const dbId = `${provider}-${job_id}`;
+          const existing = await db.select().from(fineTunedModels).where(eq(fineTunedModels.id, dbId));
+          if (existing.length > 0) {
+            const mappedStatus = (() => {
+              if (result.status === "succeeded")
+                return "succeeded";
+              if (result.status === "failed")
+                return "failed";
+              if (result.status === "cancelled")
+                return "cancelled";
+              if (result.status === "running")
+                return "running";
+              return "pending";
+            })();
+            await db.update(fineTunedModels).set({
+              status: mappedStatus,
+              updatedAt: Date.now()
+            }).where(eq(fineTunedModels.id, dbId));
           }
-          const filePath = join3(outDir, `${source}-${Date.now()}.jsonl`);
-          const jsonl = examples.map((ex) => JSON.stringify(ex)).join(`
-`);
-          writeFileSync(filePath, jsonl, "utf-8");
-          datasets.push({ source, count: examples.length, file_path: filePath });
-          totalExamples += examples.length;
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  job_id: result.jobId,
+                  status: result.status,
+                  model_id: result.fineTunedModel,
+                  error: result.error
+                }, null, 2)
+              }
+            ]
+          };
         }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ datasets, total_examples: totalExamples }, null, 2)
+        case "gather_training_data": {
+          const {
+            sources,
+            limit: limit2,
+            output_dir
+          } = args;
+          const { mkdirSync: mkdirSync2, writeFileSync } = await import("fs");
+          const { join: join3 } = await import("path");
+          const outDir = output_dir ?? defaultOutputDir();
+          mkdirSync2(outDir, { recursive: true });
+          const datasets = [];
+          let totalExamples = 0;
+          for (const source of sources) {
+            let examples = [];
+            if (source === "todos") {
+              const result = await gatherFromTodos({ limit: limit2 });
+              examples = result.examples;
+            } else {
+              examples = [];
             }
-          ]
-        };
-      }
-      case "preview_training_data": {
-        const { file_path, limit: limit2 = 5 } = args;
-        const resolvedPath = resolve(file_path);
-        if (!existsSync(resolvedPath)) {
+            const filePath = join3(outDir, `${source}-${Date.now()}.jsonl`);
+            const jsonl = examples.map((ex) => JSON.stringify(ex)).join(`
+`);
+            writeFileSync(filePath, jsonl, "utf-8");
+            datasets.push({ source, count: examples.length, file_path: filePath });
+            totalExamples += examples.length;
+          }
           return {
             content: [
-              { type: "text", text: `File not found: ${resolvedPath}` }
-            ],
-            isError: true
+              {
+                type: "text",
+                text: JSON.stringify({ datasets, total_examples: totalExamples }, null, 2)
+              }
+            ]
           };
         }
-        const content = readFileSync2(resolvedPath, "utf-8");
-        const lines = content.split(`
+        case "preview_training_data": {
+          const { file_path, limit: limit2 = 5 } = args;
+          const resolvedPath = resolve2(file_path);
+          if (!existsSync2(resolvedPath)) {
+            return {
+              content: [
+                { type: "text", text: `File not found: ${resolvedPath}` }
+              ],
+              isError: true
+            };
+          }
+          const content = readFileSync3(resolvedPath, "utf-8");
+          const lines = content.split(`
 `).map((l) => l.trim()).filter(Boolean);
-        const total = lines.length;
-        const examples = lines.slice(0, limit2).map((line) => JSON.parse(line));
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ examples, total }, null, 2)
-            }
-          ]
-        };
+          const total = lines.length;
+          const examples = lines.slice(0, limit2).map((line) => JSON.parse(line));
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ examples, total }, null, 2)
+              }
+            ]
+          };
+        }
+        default:
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            isError: true
+          };
       }
-      default:
-        return {
-          content: [{ type: "text", text: `Unknown tool: ${name}` }],
-          isError: true
-        };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
     }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      content: [{ type: "text", text: `Error: ${message}` }],
-      isError: true
-    };
-  }
-});
-var transport = new StdioServerTransport;
-await server.connect(transport);
+  });
+  return server;
+}
+async function startMcpServer(transport = new StdioServerTransport) {
+  const server = createMcpServer();
+  await server.connect(transport);
+  return server;
+}
+if (import.meta.main) {
+  await startMcpServer();
+}
+export {
+  startMcpServer,
+  createMcpServer,
+  MCP_SERVER_INFO
+};

package/dist/server/index.d.ts

@@ -1,2 +1,3 @@
-declare const port: number;
+export declare function createServerFetchHandler(version?: string): (req: Request) => Response;
+export declare function startServer(serverPort?: number): Bun.Server<undefined>;
 //# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,IAAI,QAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AASA,wBAAgB,wBAAwB,CAAC,OAAO,SAAsB,IAC5D,KAAK,OAAO,KAAG,QAAQ,CAOhC;AAED,wBAAgB,WAAW,CAAC,UAAU,SAAO,yBAM5C"}

package/dist/server/index.js

@@ -1,14 +1,54 @@
 // @bun
+// src/lib/package-metadata.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_VERSION = "0.0.0";
+var cachedVersion;
+function getPackageJsonPath() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+}
+function getPackageVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  const packageJsonPath = getPackageJsonPath();
+  if (!existsSync(packageJsonPath)) {
+    cachedVersion = DEFAULT_VERSION;
+    return cachedVersion;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    cachedVersion = typeof packageJson.version === "string" ? packageJson.version : DEFAULT_VERSION;
+  } catch {
+    cachedVersion = DEFAULT_VERSION;
+  }
+  return cachedVersion;
+}
+
 // src/server/index.ts
 var port = Number(process.env["PORT"] ?? 7020);
-console.log(`brains server starting on port ${port}`);
-Bun.serve({
-  port,
-  fetch(req) {
+var service = "brains";
+function createServerFetchHandler(version = getPackageVersion()) {
+  return (req) => {
     const url = new URL(req.url);
     if (url.pathname === "/health") {
-      return Response.json({ status: "ok", service: "brains", version: "0.0.1" });
+      return Response.json({ status: "ok", service, version });
     }
     return Response.json({ error: "not found" }, { status: 404 });
-  }
-});
+  };
+}
+function startServer(serverPort = port) {
+  console.log(`${service} server starting on port ${serverPort}`);
+  return Bun.serve({
+    port: serverPort,
+    fetch: createServerFetchHandler()
+  });
+}
+if (import.meta.main) {
+  startServer();
+}
+export {
+  startServer,
+  createServerFetchHandler
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/brains",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Fine-tuned model tracker and trainer — wraps OpenAI + Thinker Labs, gathers training data from todos/mementos/conversations/sessions",
   "type": "module",
   "main": "./dist/index.js",