mindgraph 0.1.0

package/dist/index.mjs

@@ -0,0 +1,227 @@
+// src/client.ts
+var MindGraphError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "MindGraphError";
+  }
+};
+var MindGraph = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.headers = { "Content-Type": "application/json" };
+    if (config.apiKey) {
+      this.headers["Authorization"] = `Bearer ${config.apiKey}`;
+    } else if (config.jwt) {
+      this.headers["Authorization"] = `Bearer ${config.jwt}`;
+    }
+  }
+  // ---- HTTP helpers ----
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const init = {
+      method,
+      headers: this.headers
+    };
+    if (body !== void 0) {
+      init.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      const text2 = await res.text().catch(() => "");
+      let parsed;
+      try {
+        parsed = JSON.parse(text2);
+      } catch {
+        parsed = text2;
+      }
+      throw new MindGraphError(
+        `${method} ${path} failed: ${res.status}`,
+        res.status,
+        parsed
+      );
+    }
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  get(path) {
+    return this.request("GET", path);
+  }
+  post(path, body) {
+    return this.request("POST", path, body);
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  del(path) {
+    return this.request("DELETE", path);
+  }
+  // ---- Health ----
+  async health() {
+    return this.get("/health");
+  }
+  async stats() {
+    return this.get("/stats");
+  }
+  // ---- Reality Layer ----
+  async ingest(req) {
+    return this.post("/reality/ingest", req);
+  }
+  async entity(req) {
+    return this.post("/reality/entity", req);
+  }
+  /** Convenience: create or find an entity by label. */
+  async findOrCreateEntity(label, entityType = "other", agentId) {
+    return this.post("/reality/entity", {
+      action: "create",
+      label,
+      entity_type: entityType,
+      agent_id: agentId
+    });
+  }
+  // ---- Epistemic Layer ----
+  async argue(req) {
+    return this.post("/epistemic/argument", req);
+  }
+  async inquire(req) {
+    return this.post("/epistemic/inquiry", req);
+  }
+  async structure(req) {
+    return this.post("/epistemic/structure", req);
+  }
+  // ---- Intent Layer ----
+  async commit(req) {
+    return this.post("/intent/commitment", req);
+  }
+  async deliberate(req) {
+    return this.post("/intent/deliberation", req);
+  }
+  // ---- Action Layer ----
+  async procedure(req) {
+    return this.post("/action/procedure", req);
+  }
+  async risk(req) {
+    return this.post("/action/risk", req);
+  }
+  // ---- Memory Layer ----
+  async session(req) {
+    return this.post("/memory/session", req);
+  }
+  async distill(req) {
+    return this.post("/memory/distill", req);
+  }
+  async memoryConfig(req) {
+    return this.post("/memory/config", req);
+  }
+  // ---- Agent Layer ----
+  async plan(req) {
+    return this.post("/agent/plan", req);
+  }
+  async governance(req) {
+    return this.post("/agent/governance", req);
+  }
+  async execution(req) {
+    return this.post("/agent/execution", req);
+  }
+  // ---- Cross-cutting ----
+  async retrieve(req) {
+    return this.post("/retrieve", req);
+  }
+  async traverse(req) {
+    return this.post("/traverse", req);
+  }
+  async evolve(req) {
+    return this.post("/evolve", req);
+  }
+  // ---- Node CRUD ----
+  async getNode(uid) {
+    return this.get(`/node/${uid}`);
+  }
+  async addNode(body) {
+    return this.post("/node", body);
+  }
+  async updateNode(uid, body) {
+    return this.patch(`/node/${uid}`, body);
+  }
+  async deleteNode(uid) {
+    await this.del(`/node/${uid}`);
+  }
+  // ---- Edge CRUD ----
+  async addLink(body) {
+    return this.post("/link", body);
+  }
+  async getEdges(params) {
+    const qs = new URLSearchParams();
+    if (params.from_uid) qs.set("from_uid", params.from_uid);
+    if (params.to_uid) qs.set("to_uid", params.to_uid);
+    return this.get(`/edges?${qs}`);
+  }
+  // ---- Search ----
+  async search(query, opts) {
+    return this.post("/search", { query, ...opts });
+  }
+  /** Hybrid BM25 + vector search with reciprocal rank fusion. */
+  async hybridSearch(query, opts) {
+    return this.post("/retrieve", {
+      action: "hybrid",
+      query,
+      ...opts
+    });
+  }
+  // ---- Traversal shortcuts ----
+  async reasoningChain(uid, maxDepth = 5) {
+    return this.post("/traverse", {
+      action: "chain",
+      start_uid: uid,
+      max_depth: maxDepth
+    });
+  }
+  async neighborhood(uid, maxDepth = 1) {
+    return this.post("/traverse", {
+      action: "neighborhood",
+      start_uid: uid,
+      max_depth: maxDepth
+    });
+  }
+  // ---- Lifecycle shortcuts ----
+  async tombstone(uid, reason, agentId) {
+    return this.post("/evolve", {
+      action: "tombstone",
+      uid,
+      reason,
+      agent_id: agentId
+    });
+  }
+  async restore(uid, agentId) {
+    return this.post("/evolve", {
+      action: "restore",
+      uid,
+      agent_id: agentId
+    });
+  }
+  // ---- Management (Cloud only) ----
+  async signup(email, password) {
+    return this.post("/v1/auth/signup", { email, password });
+  }
+  async login(email, password) {
+    return this.post("/v1/auth/login", { email, password });
+  }
+  async createApiKey(name = "default") {
+    return this.post("/v1/api-keys", { name });
+  }
+  async listApiKeys() {
+    return this.get("/v1/api-keys");
+  }
+  async revokeApiKey(id) {
+    await this.del(`/v1/api-keys/${id}`);
+  }
+  async getUsage() {
+    return this.get("/v1/usage");
+  }
+};
+export {
+  MindGraph,
+  MindGraphError
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "mindgraph",
+  "version": "0.1.0",
+  "description": "TypeScript client for the MindGraph Cloud API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "lint": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": ["mindgraph", "knowledge-graph", "cognitive", "ai", "agent"],
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}