@geravant/sinain 1.1.0 → 1.2.0

package/sinain-knowledge/data/store.ts

@@ -485,4 +485,121 @@ export class KnowledgeStore {
     writeFileSync(tmpPath, content, "utf-8");
     renameSync(tmpPath, situationPath);
   }
+
+  // ── Knowledge Document ─────────────────────────────────────────────────
+
+  /**
+   * Render sinain-knowledge.md — the portable knowledge document (<8KB).
+   * Combines: playbook (working memory) + top graph facts (long-term memory)
+   * + recent session digests + active module guidance.
+   */
+  renderKnowledgeDoc(): boolean {
+    try {
+      const parts: string[] = [];
+      const now = new Date().toISOString();
+
+      parts.push(`# Sinain Knowledge`);
+      parts.push(`<!-- exported: ${now}, version: 3 -->\n`);
+
+      // Playbook (working memory)
+      const playbook = this.readPlaybook();
+      if (playbook) {
+        // Strip header/footer comments for the doc
+        const body = playbook
+          .split("\n")
+          .filter((l) => !l.trim().startsWith("<!--"))
+          .join("\n")
+          .trim();
+        if (body) {
+          parts.push(`## Playbook (Working Memory)\n${body}\n`);
+        }
+      }
+
+      // Recent session digests
+      const digestsPath = join(this.workspaceDir, "memory", "session-digests.jsonl");
+      if (existsSync(digestsPath)) {
+        try {
+          const lines = readFileSync(digestsPath, "utf-8")
+            .split("\n")
+            .filter((l) => l.trim())
+            .slice(-5);
+          if (lines.length > 0) {
+            parts.push(`## Recent Sessions`);
+            for (const line of lines) {
+              try {
+                const d = JSON.parse(line);
+                if (d.whatHappened) {
+                  parts.push(`- ${d.whatHappened}`);
+                }
+              } catch {}
+            }
+            parts.push("");
+          }
+        } catch {}
+      }
+
+      // Active module guidance (brief)
+      const guidance = this.getActiveModuleGuidance();
+      if (guidance && guidance.length > 20) {
+        // Truncate to keep doc under 8KB
+        const truncated = guidance.slice(0, 2000);
+        parts.push(`## Active Modules\n${truncated}\n`);
+      }
+
+      const doc = parts.join("\n").trim() + "\n";
+      const docPath = join(this.workspaceDir, "memory", "sinain-knowledge.md");
+      const memDir = join(this.workspaceDir, "memory");
+      if (!existsSync(memDir)) mkdirSync(memDir, { recursive: true });
+      writeFileSync(docPath, doc, "utf-8");
+      this.logger.info(`sinain-hud: rendered sinain-knowledge.md (${doc.length} chars)`);
+      return true;
+    } catch (err) {
+      this.logger.warn(`sinain-hud: failed to render knowledge doc: ${String(err)}`);
+      return false;
+    }
+  }
+
+  /**
+   * Extract entity keywords from SITUATION.md for dynamic graph enrichment.
+   * Returns lowercase entity names found in the situation text.
+   */
+  extractSituationEntities(): string[] {
+    const situation = this.readSituation();
+    if (!situation) return [];
+
+    const entities: Set<string> = new Set();
+
+    // Extract from "Active Application:" line
+    const appMatch = situation.match(/Active Application:\s*(.+)/i);
+    if (appMatch) {
+      const app = appMatch[1].trim().toLowerCase().replace(/\s+/g, "-");
+      if (app.length > 2) entities.add(app);
+    }
+
+    // Extract from "Detected Errors:" section
+    const errorMatch = situation.match(/Detected Errors:[\s\S]*?(?=\n##|\n---|\Z)/i);
+    if (errorMatch) {
+      // Look for common error type patterns
+      const errorPatterns = errorMatch[0].matchAll(
+        /(?:Error|Exception|TypeError|SyntaxError|ReferenceError|HTTP\s*\d{3}|ENOENT|EACCES|timeout)/gi,
+      );
+      for (const m of errorPatterns) {
+        entities.add(m[0].toLowerCase());
+      }
+    }
+
+    // Extract technology keywords
+    const techKeywords = [
+      "react-native", "react", "flutter", "swift", "kotlin", "python",
+      "typescript", "javascript", "node", "docker", "kubernetes",
+      "intellij", "vscode", "xcode", "metro", "gradle", "cocoapods",
+      "openrouter", "anthropic", "gemini", "openclaw", "sinain",
+    ];
+    const lowerSituation = situation.toLowerCase();
+    for (const kw of techKeywords) {
+      if (lowerSituation.includes(kw)) entities.add(kw);
+    }
+
+    return [...entities].slice(0, 10);
+  }
 }

package/sinain-mcp-server/index.ts

@@ -184,26 +184,106 @@ server.tool(
   },
 );
 
-// 8. sinain_knowledge_query
+// 8. sinain_get_knowledge
+server.tool(
+  "sinain_get_knowledge",
+  "Get the portable knowledge document (playbook + long-term facts + recent sessions)",
+  {},
+  async () => {
+    try {
+      // Read pre-rendered knowledge doc (fast, no subprocess)
+      const docPath = resolve(MEMORY_DIR, "sinain-knowledge.md");
+      if (existsSync(docPath)) {
+        const content = readFileSync(docPath, "utf-8");
+        return textResult(stripPrivateTags(content));
+      }
+      // Fallback: read playbook directly
+      const playbookPath = resolve(MEMORY_DIR, "sinain-playbook.md");
+      if (existsSync(playbookPath)) {
+        return textResult(stripPrivateTags(readFileSync(playbookPath, "utf-8")));
+      }
+      return textResult("No knowledge document available yet");
+    } catch (err: any) {
+      return textResult(`Error reading knowledge: ${err.message}`);
+    }
+  },
+);
+
+// 8b. sinain_knowledge_query (graph query — entity-based lookup)
 server.tool(
   "sinain_knowledge_query",
-  "Query the knowledge graph / memory triples for relevant context",
+  "Query the knowledge graph for facts about specific entities/domains",
   {
-    context: z.string(),
-    max_chars: z.number().optional().default(1500),
+    entities: z.array(z.string()).optional().default([]),
+    max_facts: z.number().optional().default(5),
   },
-  async ({ context, max_chars }) => {
+  async ({ entities, max_facts }) => {
     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),
-      ]);
+      const dbPath = resolve(MEMORY_DIR, "knowledge-graph.db");
+      const scriptPath = resolve(SCRIPTS_DIR, "graph_query.py");
+      const args = [scriptPath, "--db", dbPath, "--max-facts", String(max_facts)];
+      if (entities.length > 0) {
+        args.push("--entities", JSON.stringify(entities));
+      }
+      const output = await runScript(args);
       return textResult(stripPrivateTags(output));
     } catch (err: any) {
-      return textResult(`Error querying knowledge: ${err.message}`);
+      return textResult(`Error querying graph: ${err.message}`);
+    }
+  },
+);
+
+// 8c. sinain_distill_session
+server.tool(
+  "sinain_distill_session",
+  "Distill the current session into knowledge (playbook updates + graph facts)",
+  {
+    session_summary: z.string().optional().default("Bare agent session distillation"),
+  },
+  async ({ session_summary }) => {
+    const results: string[] = [];
+
+    try {
+      // Fetch feed items from sinain-core
+      const coreUrl = process.env.SINAIN_CORE_URL || "http://localhost:9500";
+      const feedResp = await fetch(`${coreUrl}/feed?after=0`).then(r => r.json());
+      const historyResp = await fetch(`${coreUrl}/agent/history?limit=10`).then(r => r.json());
+
+      const feedItems = (feedResp as any).messages ?? [];
+      const agentHistory = (historyResp as any).results ?? [];
+
+      if (feedItems.length < 3) {
+        return textResult("Not enough feed items to distill (need >3)");
+      }
+
+      // Step 1: Distill
+      const transcript = JSON.stringify([...feedItems, ...agentHistory].slice(0, 100));
+      const meta = JSON.stringify({ ts: new Date().toISOString(), sessionKey: session_summary });
+
+      const distillOutput = await runScript([
+        resolve(SCRIPTS_DIR, "session_distiller.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--transcript", transcript,
+        "--session-meta", meta,
+      ], 30_000);
+      results.push(`[session_distiller] ${distillOutput.trim().slice(0, 500)}`);
+
+      const digest = JSON.parse(distillOutput.trim());
+      if (digest.isEmpty || digest.error) {
+        return textResult(`Distillation skipped: ${digest.error || "empty session"}`);
+      }
+
+      // Step 2: Integrate
+      const integrateOutput = await runScript([
+        resolve(SCRIPTS_DIR, "knowledge_integrator.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--digest", JSON.stringify(digest),
+      ], 60_000);
+      results.push(`[knowledge_integrator] ${integrateOutput.trim().slice(0, 500)}`);
+
+      return textResult(stripPrivateTags(results.join("\n\n")));
+    } catch (err: any) {
+      return textResult(`Distillation error: ${err.message}`);
     }
   },
 );

package/sinain-memory/graph_query.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Graph Query — entity-based lookup of knowledge graph facts.
+
+Thin wrapper around triplestore.py for querying facts by entity/domain.
+Used by sinain-core (via HTTP endpoint) and sinain-mcp-server (via subprocess).
+
+Usage:
+    python3 graph_query.py --db memory/knowledge-graph.db \
+        --entities '["react-native", "metro-bundler"]' \
+        [--max-facts 5] [--format text|json]
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def query_facts_by_entities(
+    db_path: str,
+    entities: list[str],
+    max_facts: int = 5,
+) -> list[dict]:
+    """Query knowledge graph for facts related to specified entities/domains."""
+    if not Path(db_path).exists():
+        return []
+
+    try:
+        from triplestore import TripleStore
+        store = TripleStore(db_path)
+
+        # Find fact entity_ids that match the requested domains or entity names
+        placeholders = ",".join(["?" for _ in entities])
+        # Match by domain attribute OR by entity name substring
+        like_clauses = " OR ".join([f"entity_id LIKE ?" for _ in entities])
+        entity_likes = [f"fact:{e}%" for e in entities]
+
+        rows = store._conn.execute(
+            f"""SELECT DISTINCT entity_id FROM triples
+                WHERE NOT retracted AND (
+                    (attribute = 'domain' AND value IN ({placeholders}))
+                    OR ({like_clauses})
+                )
+                LIMIT ?""",
+            (*entities, *entity_likes, max_facts * 3),
+        ).fetchall()
+
+        fact_ids = [r["entity_id"] for r in rows]
+
+        # Load full attributes for each fact, sorted by confidence
+        facts = []
+        for fid in fact_ids:
+            attrs = store.entity(fid)
+            if not attrs:
+                continue
+            fact = {"entityId": fid}
+            for a in attrs:
+                fact[a["attribute"]] = a["value"]
+            facts.append(fact)
+
+        # Sort by confidence descending
+        facts.sort(key=lambda f: float(f.get("confidence", "0")), reverse=True)
+        store.close()
+        return facts[:max_facts]
+    except Exception as e:
+        print(f"[warn] Graph query failed: {e}", file=sys.stderr)
+        return []
+
+
+def query_top_facts(db_path: str, limit: int = 30) -> list[dict]:
+    """Query top-N facts by confidence for knowledge doc rendering."""
+    if not Path(db_path).exists():
+        return []
+
+    try:
+        from triplestore import TripleStore
+        store = TripleStore(db_path)
+
+        rows = store._conn.execute(
+            """SELECT entity_id, CAST(value AS REAL) as conf
+               FROM triples
+               WHERE attribute = 'confidence' AND NOT retracted
+               AND entity_id LIKE 'fact:%'
+               ORDER BY conf DESC
+               LIMIT ?""",
+            (limit,),
+        ).fetchall()
+
+        facts = []
+        for row in rows:
+            fid = row["entity_id"]
+            attrs = store.entity(fid)
+            if not attrs:
+                continue
+            fact = {"entityId": fid}
+            for a in attrs:
+                fact[a["attribute"]] = a["value"]
+            facts.append(fact)
+
+        store.close()
+        return facts
+    except Exception as e:
+        print(f"[warn] Graph top-facts query failed: {e}", file=sys.stderr)
+        return []
+
+
+def format_facts_text(facts: list[dict], max_chars: int = 500) -> str:
+    """Format facts as human-readable text for escalation message injection."""
+    if not facts:
+        return ""
+
+    lines = []
+    total = 0
+    for f in facts:
+        value = f.get("value", "")
+        conf = f.get("confidence", "?")
+        count = f.get("reinforce_count", "1")
+        domain = f.get("domain", "")
+
+        line = f"- {value} (confidence: {conf}, confirmed {count}x)"
+        if domain:
+            line = f"- [{domain}] {value} (confidence: {conf}, confirmed {count}x)"
+
+        if total + len(line) > max_chars:
+            break
+        lines.append(line)
+        total += len(line)
+
+    return "\n".join(lines)
+
+
+def domain_fact_counts(db_path: str) -> dict[str, int]:
+    """Count facts per domain for module emergence detection."""
+    if not Path(db_path).exists():
+        return {}
+
+    try:
+        from triplestore import TripleStore
+        store = TripleStore(db_path)
+
+        rows = store._conn.execute(
+            """SELECT value, COUNT(DISTINCT entity_id) as cnt
+               FROM triples
+               WHERE attribute = 'domain' AND NOT retracted
+               GROUP BY value
+               ORDER BY cnt DESC""",
+        ).fetchall()
+
+        store.close()
+        return {r["value"]: r["cnt"] for r in rows}
+    except Exception:
+        return {}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Graph Query")
+    parser.add_argument("--db", required=True, help="Path to knowledge-graph.db")
+    parser.add_argument("--entities", default=None, help="JSON array of entity/domain names")
+    parser.add_argument("--top", type=int, default=None, help="Query top-N facts by confidence")
+    parser.add_argument("--domain-counts", action="store_true", help="Show fact counts per domain")
+    parser.add_argument("--max-facts", type=int, default=5, help="Maximum facts to return")
+    parser.add_argument("--format", choices=["text", "json"], default="json", help="Output format")
+    args = parser.parse_args()
+
+    if args.domain_counts:
+        counts = domain_fact_counts(args.db)
+        print(json.dumps(counts, indent=2))
+        return
+
+    if args.top is not None:
+        facts = query_top_facts(args.db, limit=args.top)
+    elif args.entities:
+        entities = json.loads(args.entities)
+        facts = query_facts_by_entities(args.db, entities, max_facts=args.max_facts)
+    else:
+        facts = query_top_facts(args.db, limit=args.max_facts)
+
+    if args.format == "text":
+        print(format_facts_text(facts))
+    else:
+        print(json.dumps({"facts": facts, "count": len(facts)}, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()