@geravant/sinain 1.0.18 → 1.1.0

package/sinain-mcp-server/index.ts

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { execFile } from "node:child_process";
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import os from "node:os";
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const SINAIN_CORE_URL = process.env.SINAIN_CORE_URL || "http://localhost:9500";
+const WORKSPACE = (process.env.SINAIN_WORKSPACE || "~/.openclaw/workspace").replace(/^~/, os.homedir());
+const MEMORY_DIR = resolve(WORKSPACE, "memory");
+const MODULES_DIR = resolve(WORKSPACE, "modules");
+
+const SCRIPTS_CANDIDATES = [
+  resolve(WORKSPACE, "sinain-memory"),
+  resolve(import.meta.dirname || ".", "..", "sinain-hud-plugin", "sinain-memory"),
+];
+const SCRIPTS_DIR = SCRIPTS_CANDIDATES.find((d) => existsSync(d)) || SCRIPTS_CANDIDATES[0];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function stripPrivateTags(text: string): string {
+  return text.replace(/<private>[\s\S]*?<\/private>/g, "[REDACTED]");
+}
+
+async function coreRequest(method: string, path: string, body?: unknown): Promise<any> {
+  const url = `${SINAIN_CORE_URL}${path}`;
+  const opts: RequestInit = {
+    method,
+    headers: { "Content-Type": "application/json" },
+  };
+  if (body) opts.body = JSON.stringify(body);
+  const res = await fetch(url, opts);
+  const json = await res.json();
+  return json;
+}
+
+function runScript(args: string[], timeoutMs = 30_000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "python3",
+      args,
+      {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env },
+      },
+      (err, stdout, stderr) => {
+        if (err) reject(new Error(`Script failed: ${err.message}\n${stderr}`));
+        else resolve(stdout);
+      },
+    );
+  });
+}
+
+function textResult(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+
+const server = new McpServer({
+  name: "sinain-mcp-server",
+  version: "0.1.0",
+});
+
+// 1. sinain_get_escalation
+server.tool(
+  "sinain_get_escalation",
+  "Get the current pending escalation from sinain-core",
+  {},
+  async () => {
+    try {
+      const data = await coreRequest("GET", "/escalation/pending");
+      if (!data || (data.status && data.status === "none")) {
+        return textResult("No pending escalation");
+      }
+      return textResult(stripPrivateTags(JSON.stringify(data, null, 2)));
+    } catch (err: any) {
+      return textResult(`Error fetching escalation: ${err.message}`);
+    }
+  },
+);
+
+// 2. sinain_respond
+server.tool(
+  "sinain_respond",
+  "Respond to a pending escalation",
+  { id: z.string(), response: z.string() },
+  async ({ id, response }) => {
+    try {
+      const data = await coreRequest("POST", "/escalation/respond", { id, response });
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error responding to escalation: ${err.message}`);
+    }
+  },
+);
+
+// 3. sinain_get_context
+server.tool(
+  "sinain_get_context",
+  "Get the current agent context window from sinain-core (screen + audio + feed)",
+  {},
+  async () => {
+    try {
+      const data = await coreRequest("GET", "/agent/context");
+      return textResult(stripPrivateTags(JSON.stringify(data, null, 2)));
+    } catch (err: any) {
+      return textResult(`Error fetching context: ${err.message}`);
+    }
+  },
+);
+
+// 4. sinain_get_digest
+server.tool(
+  "sinain_get_digest",
+  "Get the latest agent digest from sinain-core",
+  {},
+  async () => {
+    try {
+      const data = await coreRequest("GET", "/agent/digest");
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error fetching digest: ${err.message}`);
+    }
+  },
+);
+
+// 5. sinain_get_feedback
+server.tool(
+  "sinain_get_feedback",
+  "Get recent learning feedback entries",
+  { limit: z.number().optional().default(20) },
+  async ({ limit }) => {
+    try {
+      const data = await coreRequest("GET", `/learning/feedback?limit=${limit}`);
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error fetching feedback: ${err.message}`);
+    }
+  },
+);
+
+// 6. sinain_post_feed
+server.tool(
+  "sinain_post_feed",
+  "Post a message to the sinain-core HUD feed",
+  {
+    text: z.string(),
+    priority: z.enum(["normal", "high", "urgent"]).optional().default("normal"),
+  },
+  async ({ text, priority }) => {
+    try {
+      const data = await coreRequest("POST", "/feed", { text, priority });
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error posting to feed: ${err.message}`);
+    }
+  },
+);
+
+// 7. sinain_health
+server.tool(
+  "sinain_health",
+  "Check sinain-core health status",
+  {},
+  async () => {
+    try {
+      const data = await coreRequest("GET", "/health");
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error checking health: ${err.message}`);
+    }
+  },
+);
+
+// 8. sinain_knowledge_query
+server.tool(
+  "sinain_knowledge_query",
+  "Query the knowledge graph / memory triples for relevant context",
+  {
+    context: z.string(),
+    max_chars: z.number().optional().default(1500),
+  },
+  async ({ context, max_chars }) => {
+    try {
+      const scriptPath = resolve(SCRIPTS_DIR, "triple_query.py");
+      const output = await runScript([
+        scriptPath,
+        "--memory-dir", MEMORY_DIR,
+        "--context", context,
+        "--max-chars", String(max_chars),
+      ]);
+      return textResult(stripPrivateTags(output));
+    } catch (err: any) {
+      return textResult(`Error querying knowledge: ${err.message}`);
+    }
+  },
+);
+
+// 9. sinain_heartbeat_tick
+server.tool(
+  "sinain_heartbeat_tick",
+  "Run the full heartbeat knowledge pipeline (signal analysis, insight synthesis, memory mining, playbook curation)",
+  {
+    session_summary: z.string().optional().default("Bare agent heartbeat tick"),
+  },
+  async ({ session_summary }) => {
+    const results: string[] = [];
+    const now = new Date().toISOString();
+
+    // Step 1: git_backup.sh
+    const gitBackupPath = resolve(SCRIPTS_DIR, "git_backup.sh");
+    if (existsSync(gitBackupPath)) {
+      try {
+        const out = await new Promise<string>((res, rej) => {
+          execFile("bash", [gitBackupPath, MEMORY_DIR], { timeout: 30_000 }, (err, stdout, stderr) => {
+            if (err) rej(new Error(`git_backup failed: ${err.message}\n${stderr}`));
+            else res(stdout);
+          });
+        });
+        results.push(`[git_backup] ${out.trim() || "OK"}`);
+      } catch (err: any) {
+        results.push(`[git_backup] FAILED: ${err.message}`);
+      }
+    }
+
+    // Step 2: signal_analyzer.py
+    try {
+      const out = await runScript([
+        resolve(SCRIPTS_DIR, "signal_analyzer.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--session-summary", session_summary,
+        "--current-time", now,
+      ]);
+      results.push(`[signal_analyzer] ${out.trim() || "OK"}`);
+    } catch (err: any) {
+      results.push(`[signal_analyzer] FAILED: ${err.message}`);
+    }
+
+    // Step 3: insight_synthesizer.py
+    try {
+      const out = await runScript([
+        resolve(SCRIPTS_DIR, "insight_synthesizer.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--session-summary", session_summary,
+      ]);
+      results.push(`[insight_synthesizer] ${out.trim() || "OK"}`);
+    } catch (err: any) {
+      results.push(`[insight_synthesizer] FAILED: ${err.message}`);
+    }
+
+    // Step 4: memory_miner.py
+    try {
+      const out = await runScript([
+        resolve(SCRIPTS_DIR, "memory_miner.py"),
+        "--memory-dir", MEMORY_DIR,
+      ]);
+      results.push(`[memory_miner] ${out.trim() || "OK"}`);
+    } catch (err: any) {
+      results.push(`[memory_miner] FAILED: ${err.message}`);
+    }
+
+    // Step 5: playbook_curator.py
+    try {
+      const out = await runScript([
+        resolve(SCRIPTS_DIR, "playbook_curator.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--session-summary", session_summary,
+      ]);
+      results.push(`[playbook_curator] ${out.trim() || "OK"}`);
+    } catch (err: any) {
+      results.push(`[playbook_curator] FAILED: ${err.message}`);
+    }
+
+    return textResult(stripPrivateTags(results.join("\n\n")));
+  },
+);
+
+// 10. sinain_module_guidance
+server.tool(
+  "sinain_module_guidance",
+  "Read guidance from all active modules in the workspace",
+  {},
+  async () => {
+    try {
+      const registryPath = resolve(MODULES_DIR, "module-registry.json");
+      if (!existsSync(registryPath)) {
+        return textResult("No modules configured");
+      }
+
+      const registry = JSON.parse(readFileSync(registryPath, "utf-8"));
+      const modules: Array<{ name: string; active?: boolean }> = Array.isArray(registry)
+        ? registry
+        : registry.modules || [];
+
+      const parts: string[] = [];
+      for (const mod of modules) {
+        if (mod.active === false) continue;
+        const guidancePath = resolve(MODULES_DIR, mod.name, "guidance.md");
+        if (existsSync(guidancePath)) {
+          const content = readFileSync(guidancePath, "utf-8");
+          parts.push(`## ${mod.name}\n\n${content}`);
+        }
+      }
+
+      if (parts.length === 0) {
+        return textResult("No module guidance files found");
+      }
+      return textResult(stripPrivateTags(parts.join("\n\n---\n\n")));
+    } catch (err: any) {
+      return textResult(`Error reading module guidance: ${err.message}`);
+    }
+  },
+);
+
+// ---------------------------------------------------------------------------
+// Startup
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`sinain-mcp-server started (core=${SINAIN_CORE_URL}, workspace=${WORKSPACE})`);
+}
+
+main().catch(console.error);

package/sinain-mcp-server/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "sinain-mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP server for sinain-hud bare agent integration",
+  "main": "index.ts",
+  "scripts": {
+    "start": "npx tsx index.ts",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.7",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/sinain-mcp-server/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["dist"]
+}