mindgraph 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,393 @@
+interface GraphNode {
+    uid: string;
+    label: string;
+    summary: string;
+    node_type: string;
+    layer: string;
+    confidence: number;
+    salience: number;
+    props: Record<string, unknown>;
+    created_at: number;
+    updated_at: number;
+    tombstone_at: number | null;
+}
+interface GraphEdge {
+    uid: string;
+    from_uid: string;
+    to_uid: string;
+    edge_type: string;
+    layer: string;
+    weight: number;
+    props: Record<string, unknown>;
+    created_at: number;
+    updated_at: number;
+    tombstone_at: number | null;
+}
+interface SearchResult {
+    uid: string;
+    label: string;
+    summary: string;
+    node_type: string;
+    score: number;
+}
+interface PathStep {
+    uid: string;
+    label: string;
+    node_type: string;
+    edge_type: string | null;
+    depth: number;
+    parent_uid: string | null;
+}
+interface IngestRequest {
+    action: "source" | "snippet" | "observation";
+    label: string;
+    content: string;
+    source_uid?: string;
+    medium?: string;
+    url?: string;
+    timestamp?: number;
+    confidence?: number;
+    salience?: number;
+    agent_id?: string;
+}
+interface EntityRequest {
+    action: "create" | "alias" | "resolve" | "fuzzy_resolve" | "merge" | "relate";
+    label?: string;
+    entity_type?: string;
+    text?: string;
+    canonical_uid?: string;
+    alias_score?: number;
+    keep_uid?: string;
+    merge_uid?: string;
+    limit?: number;
+    source_uid?: string;
+    target_uid?: string;
+    edge_type?: string;
+    agent_id?: string;
+}
+interface ArgumentRequest {
+    claim: {
+        label: string;
+        content: string;
+        confidence?: number;
+    };
+    evidence?: {
+        label: string;
+        description: string;
+        evidence_type?: string;
+    }[];
+    warrant?: {
+        label: string;
+        principle: string;
+    };
+    argument?: {
+        label: string;
+        summary: string;
+    };
+    refutes_uid?: string;
+    extends_uid?: string;
+    source_uids?: string[];
+    agent_id?: string;
+}
+interface InquiryRequest {
+    action: "hypothesis" | "theory" | "paradigm" | "anomaly" | "assumption" | "question" | "open_question";
+    label: string;
+    content: string;
+    status?: string;
+    anomalous_to_uid?: string;
+    assumes_uid?: string[];
+    tests_uid?: string;
+    addresses_uid?: string;
+    confidence?: number;
+    salience?: number;
+    related_uids?: string[];
+    agent_id?: string;
+}
+interface StructureRequest {
+    action: "concept" | "pattern" | "mechanism" | "model" | "model_evaluation" | "analogy" | "inference_chain" | "reasoning_strategy" | "sensitivity_analysis" | "theorem" | "equation";
+    label: string;
+    content: string;
+    summary?: string;
+    analogous_to_uid?: string;
+    transfers_to_uid?: string[];
+    evaluates_uid?: string;
+    outperforms_uid?: string;
+    chain_steps?: string[];
+    derived_from_uid?: string[];
+    proven_by_uid?: string;
+    related_uids?: string[];
+    confidence?: number;
+    agent_id?: string;
+}
+interface CommitmentRequest {
+    action: "goal" | "project" | "milestone";
+    label: string;
+    description: string;
+    priority?: string;
+    status?: string;
+    parent_uid?: string;
+    due_date?: number;
+    motivated_by_uid?: string[];
+    agent_id?: string;
+}
+interface DeliberationRequest {
+    action: "open_decision" | "add_option" | "add_constraint" | "resolve" | "get_open";
+    label?: string;
+    description?: string;
+    decision_uid?: string;
+    chosen_option_uid?: string;
+    resolution_rationale?: string;
+    constraint_type?: string;
+    blocks_uid?: string;
+    informs_uid?: string[];
+    agent_id?: string;
+}
+interface ProcedureRequest {
+    action: "create_flow" | "add_step" | "add_affordance" | "add_control";
+    label: string;
+    description?: string;
+    flow_uid?: string;
+    step_order?: number;
+    previous_step_uid?: string;
+    affordance_type?: string;
+    control_type?: string;
+    uses_affordance_uids?: string[];
+    goal_uid?: string;
+    agent_id?: string;
+}
+interface RiskRequest {
+    action: "assess" | "get_assessments";
+    label?: string;
+    description?: string;
+    assessed_uid?: string;
+    severity?: string;
+    likelihood?: number;
+    mitigations?: string[];
+    residual_risk?: number;
+    filter_uid?: string;
+    agent_id?: string;
+}
+interface SessionRequest {
+    action: "open" | "trace" | "close";
+    label?: string;
+    focus?: string;
+    session_uid?: string;
+    trace_content?: string;
+    trace_type?: string;
+    relevant_node_uids?: string[];
+    agent_id?: string;
+}
+interface DistillRequest {
+    label: string;
+    content: string;
+    summarizes_uids?: string[];
+    session_uid?: string;
+    importance?: number;
+    agent_id?: string;
+}
+interface MemoryConfigRequest {
+    action: "set_preference" | "get_preferences" | "set_policy" | "get_policies";
+    label?: string;
+    key?: string;
+    value?: string;
+    policy_content?: string;
+    agent_id?: string;
+}
+interface PlanRequest {
+    action: "create_task" | "create_plan" | "add_step" | "update_status" | "get_plan";
+    label?: string;
+    description?: string;
+    goal_uid?: string;
+    task_uid?: string;
+    plan_uid?: string;
+    step_order?: number;
+    depends_on_uids?: string[];
+    target_uid?: string;
+    status?: string;
+    related_uids?: string[];
+    agent_id?: string;
+}
+interface GovernanceRequest {
+    action: "create_policy" | "set_budget" | "request_approval" | "resolve_approval" | "get_pending";
+    label?: string;
+    policy_content?: string;
+    budget_type?: string;
+    budget_limit?: number;
+    governed_uid?: string;
+    approval_uid?: string;
+    approved?: boolean;
+    resolution_note?: string;
+    requires_plan_uid?: string;
+    approval_request?: string;
+    agent_id?: string;
+}
+interface ExecutionRequest {
+    action: "start" | "complete" | "fail" | "register_agent" | "get_executions";
+    label?: string;
+    plan_uid?: string;
+    executor_uid?: string;
+    execution_uid?: string;
+    outcome?: string;
+    produces_node_uid?: string;
+    error_description?: string;
+    agent_name?: string;
+    agent_role?: string;
+    filter_plan_uid?: string;
+    related_uids?: string[];
+    agent_id?: string;
+}
+interface RetrieveRequest {
+    action: "text" | "semantic" | "hybrid" | "active_goals" | "open_questions" | "weak_claims" | "pending_approvals" | "unresolved_contradictions" | "layer" | "recent";
+    query?: string;
+    k?: number;
+    threshold?: number;
+    layer?: string;
+    node_types?: string[];
+    confidence_min?: number;
+    salience_min?: number;
+    limit?: number;
+    offset?: number;
+}
+interface TraverseRequest {
+    action: "chain" | "neighborhood" | "path" | "subgraph";
+    start_uid: string;
+    end_uid?: string;
+    max_depth?: number;
+    direction?: "outgoing" | "incoming" | "both";
+    edge_types?: string[];
+    weight_threshold?: number;
+}
+interface EvolveRequest {
+    action: "update" | "tombstone" | "restore" | "decay" | "history" | "snapshot" | "tombstone_edge" | "restore_edge" | "tombstone_cascade";
+    uid: string;
+    label?: string;
+    summary?: string;
+    confidence?: number;
+    salience?: number;
+    props_patch?: Record<string, unknown>;
+    reason?: string;
+    cascade?: boolean;
+    half_life_secs?: number;
+    min_salience?: number;
+    min_age_secs?: number;
+    version?: number;
+    agent_id?: string;
+}
+interface SignupRequest {
+    email: string;
+    password: string;
+}
+interface LoginRequest {
+    email: string;
+    password: string;
+}
+interface CreateOrgRequest {
+    name: string;
+    slug?: string;
+}
+interface CreateApiKeyRequest {
+    name?: string;
+}
+interface ApiKeyResponse {
+    id: string;
+    key: string;
+    name: string;
+    prefix: string;
+}
+interface MindGraphConfig {
+    baseUrl: string;
+    apiKey?: string;
+    jwt?: string;
+}
+
+declare class MindGraphError extends Error {
+    status: number;
+    body?: unknown | undefined;
+    constructor(message: string, status: number, body?: unknown | undefined);
+}
+declare class MindGraph {
+    private baseUrl;
+    private headers;
+    constructor(config: MindGraphConfig);
+    private request;
+    private get;
+    private post;
+    private patch;
+    private del;
+    health(): Promise<{
+        status: string;
+    }>;
+    stats(): Promise<Record<string, unknown>>;
+    ingest(req: IngestRequest): Promise<unknown>;
+    entity(req: EntityRequest): Promise<unknown>;
+    /** Convenience: create or find an entity by label. */
+    findOrCreateEntity(label: string, entityType?: string, agentId?: string): Promise<GraphNode & {
+        created: boolean;
+    }>;
+    argue(req: ArgumentRequest): Promise<unknown>;
+    inquire(req: InquiryRequest): Promise<unknown>;
+    structure(req: StructureRequest): Promise<unknown>;
+    commit(req: CommitmentRequest): Promise<unknown>;
+    deliberate(req: DeliberationRequest): Promise<unknown>;
+    procedure(req: ProcedureRequest): Promise<unknown>;
+    risk(req: RiskRequest): Promise<unknown>;
+    session(req: SessionRequest): Promise<unknown>;
+    distill(req: DistillRequest): Promise<unknown>;
+    memoryConfig(req: MemoryConfigRequest): Promise<unknown>;
+    plan(req: PlanRequest): Promise<unknown>;
+    governance(req: GovernanceRequest): Promise<unknown>;
+    execution(req: ExecutionRequest): Promise<unknown>;
+    retrieve(req: RetrieveRequest): Promise<unknown>;
+    traverse(req: TraverseRequest): Promise<unknown>;
+    evolve(req: EvolveRequest): Promise<unknown>;
+    getNode(uid: string): Promise<GraphNode>;
+    addNode(body: {
+        label: string;
+        node_type?: string;
+        props?: Record<string, unknown>;
+        agent_id?: string;
+    }): Promise<GraphNode>;
+    updateNode(uid: string, body: {
+        label?: string;
+        summary?: string;
+        confidence?: number;
+        salience?: number;
+        agent_id?: string;
+    }): Promise<GraphNode>;
+    deleteNode(uid: string): Promise<void>;
+    addLink(body: {
+        from_uid: string;
+        to_uid: string;
+        edge_type: string;
+        agent_id?: string;
+    }): Promise<unknown>;
+    getEdges(params: {
+        from_uid?: string;
+        to_uid?: string;
+    }): Promise<GraphEdge[]>;
+    search(query: string, opts?: {
+        node_type?: string;
+        layer?: string;
+        limit?: number;
+    }): Promise<SearchResult[]>;
+    /** Hybrid BM25 + vector search with reciprocal rank fusion. */
+    hybridSearch(query: string, opts?: {
+        k?: number;
+        node_types?: string[];
+        layer?: string;
+    }): Promise<SearchResult[]>;
+    reasoningChain(uid: string, maxDepth?: number): Promise<PathStep[]>;
+    neighborhood(uid: string, maxDepth?: number): Promise<PathStep[]>;
+    tombstone(uid: string, reason?: string, agentId?: string): Promise<unknown>;
+    restore(uid: string, agentId?: string): Promise<unknown>;
+    signup(email: string, password: string): Promise<unknown>;
+    login(email: string, password: string): Promise<unknown>;
+    createApiKey(name?: string): Promise<ApiKeyResponse>;
+    listApiKeys(): Promise<{
+        api_keys: unknown[];
+    }>;
+    revokeApiKey(id: string): Promise<void>;
+    getUsage(): Promise<unknown>;
+}
+
+export { type ApiKeyResponse, type ArgumentRequest, type CommitmentRequest, type CreateApiKeyRequest, type CreateOrgRequest, type DeliberationRequest, type DistillRequest, type EntityRequest, type EvolveRequest, type ExecutionRequest, type GovernanceRequest, type GraphEdge, type GraphNode, type IngestRequest, type InquiryRequest, type LoginRequest, type MemoryConfigRequest, MindGraph, type MindGraphConfig, MindGraphError, type PathStep, type PlanRequest, type ProcedureRequest, type RetrieveRequest, type RiskRequest, type SearchResult, type SessionRequest, type SignupRequest, type StructureRequest, type TraverseRequest };

package/dist/index.js

@@ -0,0 +1,255 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MindGraph: () => MindGraph,
+  MindGraphError: () => MindGraphError
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MindGraph,
+  MindGraphError
+});