@duckmind/deepquark-darwin-arm64 0.9.83 → 0.9.90

package/.deepquark/skills/bundled/knowledge-graph/server/test-real-life-mcp.ts

@@ -0,0 +1,311 @@
+#!/usr/bin/env bun
+/**
+ * Real-life MCP Knowledge System Test
+ * Tests the actual add_memory, search_nodes, and search_memory_facts operations
+ * by calling the MCP server directly via HTTP/SSE protocol
+ */
+
+// Test data - realistic knowledge scenarios
+const TEST_EPISODES = [
+  {
+    name: 'Tech Stack Decision',
+    body: 'The team decided to use TypeScript with Bun runtime for the new API project. Sarah recommended Hono for the HTTP framework due to its performance and edge compatibility.',
+    source: 'text',
+    group_id: 'mcp-test',
+  },
+  {
+    name: 'Meeting Notes',
+    body: "John Smith from Acme Corp met with our CTO Alice Chen to discuss the Q1 roadmap. They agreed on a partnership to integrate Acme's payment API into our platform.",
+    source: 'text',
+    group_id: 'mcp-test',
+  },
+  {
+    name: 'Technical Documentation',
+    body: "The PAI system uses Neo4j as the graph database backend. OpenAI's gpt-4o-mini is configured for entity extraction, while mxbai-embed-large running on Ollama handles embeddings.",
+    source: 'text',
+    group_id: 'mcp-test',
+  },
+];
+
+const SEARCH_QUERIES = [
+  { query: 'What technology stack is being used?', expected: ['TypeScript', 'Bun', 'Hono'] },
+  { query: 'Who is working with Acme Corp?', expected: ['John Smith', 'Alice Chen', 'Acme Corp'] },
+  { query: 'What database does PAI use?', expected: ['Neo4j', 'PAI'] },
+];
+
+async function testDirectAPI() {
+  console.log('═'.repeat(60));
+  console.log('🧪 Real-Life MCP Knowledge System Test');
+  console.log('═'.repeat(60));
+
+  // Test 1: Health check
+  console.log('\n📋 Test 1: Health Check');
+  const health = await fetch('http://localhost:8000/health').then((r) => r.json());
+  console.log(`   Status: ${health.status}`);
+  console.log(`   Patch: ${health.patch || 'none'}`);
+
+  // For actual MCP testing, we'll use the MCP protocol via curl or a proper client
+  console.log('\n📋 Testing via MCP protocol requires session management...');
+  console.log('   Using direct curl tests instead:\n');
+}
+
+async function runCurlTests() {
+  const results: any[] = [];
+
+  // Test add_memory
+  console.log('═'.repeat(60));
+  console.log('📥 TEST: add_memory operations');
+  console.log('═'.repeat(60));
+
+  for (const episode of TEST_EPISODES) {
+    const start = Date.now();
+    const proc = Bun.spawn([
+      'curl',
+      '-sf',
+      '-X',
+      'POST',
+      'http://localhost:8000/mcp',
+      '-H',
+      'Content-Type: application/json',
+      '-H',
+      'Accept: text/event-stream',
+      '-d',
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'tools/call',
+        params: {
+          name: 'add_memory',
+          arguments: {
+            name: episode.name,
+            episode_body: episode.body,
+            source: episode.source,
+            group_id: episode.group_id,
+          },
+        },
+      }),
+    ]);
+
+    const output = await new Response(proc.stdout).text();
+    const duration = Date.now() - start;
+
+    const success = output.includes('result') && !output.includes('error');
+    console.log(`\n   ${success ? '✅' : '❌'} "${episode.name}" (${duration}ms)`);
+    if (!success) console.log(`      Response: ${output.slice(0, 200)}`);
+
+    results.push({
+      operation: 'add_memory',
+      name: episode.name,
+      success,
+      duration,
+    });
+
+    await new Promise((r) => setTimeout(r, 2000)); // Wait for processing
+  }
+
+  // Test search_nodes
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log('🔍 TEST: search_nodes operations');
+  console.log('═'.repeat(60));
+
+  for (const search of SEARCH_QUERIES) {
+    const start = Date.now();
+    const proc = Bun.spawn([
+      'curl',
+      '-sf',
+      '-X',
+      'POST',
+      'http://localhost:8000/mcp',
+      '-H',
+      'Content-Type: application/json',
+      '-H',
+      'Accept: text/event-stream',
+      '-d',
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'tools/call',
+        params: {
+          name: 'search_nodes',
+          arguments: {
+            query: search.query,
+            group_ids: ['mcp-test'],
+            max_nodes: 10,
+          },
+        },
+      }),
+    ]);
+
+    const output = await new Response(proc.stdout).text();
+    const duration = Date.now() - start;
+
+    // Check if any expected entities were found
+    const foundExpected = search.expected.some((e) =>
+      output.toLowerCase().includes(e.toLowerCase())
+    );
+    console.log(`\n   ${foundExpected ? '✅' : '⚠️'} "${search.query}" (${duration}ms)`);
+
+    // Parse and show found nodes
+    try {
+      const lines = output.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = JSON.parse(line.slice(6));
+          if (data.result?.content?.[0]?.text) {
+            const nodes = JSON.parse(data.result.content[0].text);
+            if (nodes.nodes?.length > 0) {
+              console.log(`      Found ${nodes.nodes.length} nodes:`);
+              nodes.nodes.slice(0, 3).forEach((n: any) => {
+                console.log(`        - ${n.name} (${n.entity_type})`);
+              });
+            }
+          }
+        }
+      }
+    } catch (_e) {
+      // Output parsing failed
+    }
+
+    results.push({
+      operation: 'search_nodes',
+      query: search.query,
+      success: foundExpected,
+      duration,
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+  }
+
+  // Test search_memory_facts
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log('🔗 TEST: search_memory_facts operations');
+  console.log('═'.repeat(60));
+
+  const factQueries = [
+    'partnership between companies',
+    'technology decisions',
+    'database configuration',
+  ];
+
+  for (const query of factQueries) {
+    const start = Date.now();
+    const proc = Bun.spawn([
+      'curl',
+      '-sf',
+      '-X',
+      'POST',
+      'http://localhost:8000/mcp',
+      '-H',
+      'Content-Type: application/json',
+      '-H',
+      'Accept: text/event-stream',
+      '-d',
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'tools/call',
+        params: {
+          name: 'search_memory_facts',
+          arguments: {
+            query: query,
+            group_ids: ['mcp-test'],
+            max_facts: 5,
+          },
+        },
+      }),
+    ]);
+
+    const output = await new Response(proc.stdout).text();
+    const duration = Date.now() - start;
+
+    const hasFacts = output.includes('facts') && !output.includes('"facts":[]');
+    console.log(`\n   ${hasFacts ? '✅' : '⚠️'} "${query}" (${duration}ms)`);
+
+    // Parse and show facts
+    try {
+      const lines = output.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data = JSON.parse(line.slice(6));
+          if (data.result?.content?.[0]?.text) {
+            const facts = JSON.parse(data.result.content[0].text);
+            if (facts.facts?.length > 0) {
+              console.log(`      Found ${facts.facts.length} facts:`);
+              facts.facts.slice(0, 3).forEach((f: any) => {
+                console.log(`        - ${f.fact?.slice(0, 80)}...`);
+              });
+            }
+          }
+        }
+      }
+    } catch (_e) {
+      // Output parsing failed
+    }
+
+    results.push({
+      operation: 'search_memory_facts',
+      query: query,
+      success: hasFacts,
+      duration,
+    });
+
+    await new Promise((r) => setTimeout(r, 500));
+  }
+
+  // Summary
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log('📊 RESULTS SUMMARY');
+  console.log('═'.repeat(60));
+
+  const byOperation = results.reduce(
+    (acc, r) => {
+      if (!acc[r.operation]) acc[r.operation] = { success: 0, total: 0, totalMs: 0 };
+      acc[r.operation].total++;
+      if (r.success) acc[r.operation].success++;
+      acc[r.operation].totalMs += r.duration;
+      return acc;
+    },
+    {} as Record<string, { success: number; total: number; totalMs: number }>
+  );
+
+  console.log('\n| Operation          | Success Rate | Avg Duration |');
+  console.log('|--------------------|--------------|--------------|');
+  for (const [op, stats] of Object.entries(byOperation)) {
+    const rate = ((stats.success / stats.total) * 100).toFixed(0);
+    const avgMs = Math.round(stats.totalMs / stats.total);
+    console.log(`| ${op.padEnd(18)} | ${rate.padStart(10)}% | ${(`${avgMs}ms`).padStart(12)} |`);
+  }
+
+  // Save results
+  await Bun.write(
+    'mcp-test-results.json',
+    JSON.stringify(
+      {
+        results,
+        summary: byOperation,
+        timestamp: new Date().toISOString(),
+        config: {
+          llm: 'gpt-4o-mini',
+          embedder: 'openai',
+          database: 'neo4j',
+        },
+      },
+      null,
+      2
+    )
+  );
+
+  console.log('\n📁 Results saved to mcp-test-results.json');
+}
+
+async function main() {
+  try {
+    await testDirectAPI();
+    await runCurlTests();
+  } catch (err: any) {
+    console.error('Test failed:', err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/.deepquark/skills/bundled/knowledge-graph/server/test-search-debug.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env bun
+/**
+ * Debug search_nodes and search_memory_facts
+ * Data is confirmed in Neo4j - need to understand why searches fail
+ */
+
+const MCP_URL = 'http://localhost:8000/mcp';
+const ACCEPT = 'application/json, text/event-stream';
+
+let sessionId: string | null = null;
+
+async function mcpRequest(method: string, params: any = {}): Promise<any> {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    Accept: ACCEPT,
+  };
+
+  if (sessionId) {
+    headers['mcp-session-id'] = sessionId;
+  }
+
+  const res = await fetch(MCP_URL, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method,
+      params,
+    }),
+  });
+
+  // Capture session ID from response
+  const newSessionId = res.headers.get('mcp-session-id');
+  if (newSessionId) sessionId = newSessionId;
+
+  const text = await res.text();
+
+  // Parse SSE or JSON response
+  let result: any = null;
+  let error: any = null;
+
+  for (const line of text.split('\n')) {
+    if (line.startsWith('data: ')) {
+      try {
+        const data = JSON.parse(line.slice(6));
+        if (data.result) result = data.result;
+        if (data.error) error = data.error;
+      } catch {}
+    }
+  }
+
+  // Fallback to direct JSON
+  if (!result && !error) {
+    try {
+      const json = JSON.parse(text);
+      result = json.result;
+      error = json.error;
+    } catch {}
+  }
+
+  return { result, error, raw: text };
+}
+
+async function callTool(
+  name: string,
+  args: any
+): Promise<{ success: boolean; data: any; duration: number; raw: string }> {
+  const start = Date.now();
+  const { result, error, raw } = await mcpRequest('tools/call', { name, arguments: args });
+  const duration = Date.now() - start;
+
+  if (error) {
+    return { success: false, data: error, duration, raw };
+  }
+
+  // Parse tool result content
+  let data: any = result;
+  try {
+    if (result?.content?.[0]?.text) {
+      data = JSON.parse(result.content[0].text);
+    }
+  } catch {}
+
+  return { success: true, data, duration, raw };
+}
+
+async function main() {
+  console.log('═'.repeat(60));
+  console.log('🔍 Search Debug Test - Data confirmed in Neo4j');
+  console.log('═'.repeat(60));
+
+  // Initialize session
+  console.log('\n📋 Initializing MCP session...');
+  const _initRes = await mcpRequest('initialize', {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: { name: 'search-debug', version: '1.0' },
+  });
+  console.log(`   Session: ${sessionId}`);
+
+  await mcpRequest('notifications/initialized', {});
+
+  // Test 1: Search for exact entity names that exist
+  console.log(`\n${'─'.repeat(60)}`);
+  console.log('Test 1: Search exact entity names');
+  console.log('─'.repeat(60));
+
+  const exactQueries = ['TypeScript', 'Acme Corp', 'Sarah', 'Neo4j'];
+  for (const q of exactQueries) {
+    const res = await callTool('search_nodes', {
+      query: q,
+      group_ids: ['mcp-test'],
+      max_nodes: 10,
+    });
+
+    const nodes = res.data?.nodes || [];
+    console.log(`\n"${q}" → ${nodes.length} nodes (${res.duration}ms)`);
+
+    if (nodes.length > 0) {
+      nodes.slice(0, 3).forEach((n: any) => console.log(`   ✅ ${n.name} (${n.entity_type})`));
+    } else {
+      console.log('   ⚠️  No results. Raw response sample:');
+      console.log(`   ${res.raw.slice(0, 200)}`);
+    }
+
+    await Bun.sleep(300);
+  }
+
+  // Test 2: Search without group_id filter
+  console.log(`\n${'─'.repeat(60)}`);
+  console.log('Test 2: Search without group_id filter');
+  console.log('─'.repeat(60));
+
+  const res2 = await callTool('search_nodes', {
+    query: 'TypeScript',
+    max_nodes: 10,
+  });
+  const nodes2 = res2.data?.nodes || [];
+  console.log(`\n"TypeScript" (no group filter) → ${nodes2.length} nodes (${res2.duration}ms)`);
+  nodes2.slice(0, 3).forEach((n: any) => console.log(`   ✅ ${n.name}`));
+
+  // Test 3: Search facts
+  console.log(`\n${'─'.repeat(60)}`);
+  console.log('Test 3: Search facts');
+  console.log('─'.repeat(60));
+
+  const factQueries = ['partnership', 'technology', 'framework'];
+  for (const q of factQueries) {
+    const res = await callTool('search_memory_facts', {
+      query: q,
+      group_ids: ['mcp-test'],
+      max_facts: 10,
+    });
+
+    const facts = res.data?.facts || [];
+    console.log(`\n"${q}" → ${facts.length} facts (${res.duration}ms)`);
+
+    if (facts.length > 0) {
+      facts.slice(0, 2).forEach((f: any) => console.log(`   ✅ ${f.fact?.slice(0, 80)}...`));
+    } else {
+      console.log('   ⚠️  No results');
+    }
+
+    await Bun.sleep(300);
+  }
+
+  // Test 4: Get episodes to verify data
+  console.log(`\n${'─'.repeat(60)}`);
+  console.log('Test 4: Get episodes via MCP');
+  console.log('─'.repeat(60));
+
+  const epRes = await callTool('get_episodes', {
+    group_ids: ['mcp-test'],
+    max_episodes: 10,
+  });
+
+  const episodes = epRes.data?.episodes || [];
+  console.log(`\nEpisodes in mcp-test: ${episodes.length}`);
+  episodes.forEach((ep: any) => console.log(`   📄 ${ep.name || ep.uuid}`));
+
+  // Summary
+  console.log(`\n${'═'.repeat(60)}`);
+  console.log('📊 DEBUG SUMMARY');
+  console.log('═'.repeat(60));
+  console.log(`
+Data exists in Neo4j (verified via cypher-shell):
+- Entities: TypeScript, Bun, Sarah, Hono, John Smith, Acme Corp, Alice Chen
+- Episodes: Tech Stack, Partnership, PAI System
+- Group: mcp-test
+
+If searches return 0 results, possible causes:
+1. Embedding dimension mismatch between storage and query
+2. Vector index not created or not matching
+3. Group ID filter issue in search query
+  `);
+}
+
+main().catch(console.error);

package/.deepquark/skills/bundled/knowledge-graph/tools/Install.md

@@ -0,0 +1,104 @@
+# Install Knowledge System
+
+Workflow for installing and configuring the Madeinoz Knowledge System.
+
+## When to Use
+
+Use this workflow when the user requests:
+- "install knowledge"
+- "setup knowledge system"
+- "configure knowledge graph"
+- "install knowledge system"
+
+## Prerequisites Check
+
+Before installation, verify:
+
+1. **Container runtime available:**
+   ```bash
+   command -v podman || command -v docker
+   ```
+
+2. **Bun runtime installed:**
+   ```bash
+   command -v bun
+   ```
+
+3. **API key configured:**
+   - Check for `MADEINOZ_KNOWLEDGE_OPENAI_API_KEY` in PAI config (`$PAI_DIR/.env` or `~/.claude/.env`)
+   - Legacy `OPENAI_API_KEY` is also supported but `MADEINOZ_KNOWLEDGE_*` prefix is preferred
+
+4. **Neo4j connection configured (for Neo4j backend):**
+   - Add to PAI config (`~/.claude/.env`):
+     ```bash
+     MADEINOZ_KNOWLEDGE_NEO4J_URI=bolt://neo4j:7687
+     MADEINOZ_KNOWLEDGE_NEO4J_USER=neo4j
+     MADEINOZ_KNOWLEDGE_NEO4J_PASSWORD=madeinozknowledge
+     ```
+   - Note: Use `bolt://neo4j:7687` (container hostname) not `bolt://localhost:7687`
+
+## Installation Steps
+
+### Step 1: Start MCP Server
+
+```bash
+cd /path/to/madeinoz-knowledge-system
+bun run server-cli start
+```
+
+### Step 2: Verify Server Health
+
+```bash
+curl -s http://localhost:8000/health
+```
+
+Expected: `{"status":"healthy"}`
+
+### Step 3: Install Skill
+
+```bash
+PAI_SKILLS_DIR="${PAI_DIR:-$HOME/.claude}/skills"
+cp -r src/skills "$PAI_SKILLS_DIR/Knowledge"
+```
+
+### Step 4: Configure MCP in Claude
+
+Add to `~/.claude.json`:
+```json
+{
+  "mcpServers": {
+    "madeinoz-knowledge": {
+      "type": "http",
+      "url": "http://localhost:8000/mcp"
+    }
+  }
+}
+```
+
+### Step 5: Restart Claude Code
+
+Restart Claude Code to load the MCP configuration.
+
+## Verification
+
+After installation, test with:
+
+1. **Check status:** "Show knowledge graph status"
+2. **Capture test:** "Remember that Madeinoz Knowledge System is now installed"
+3. **Search test:** "What do I know about PAI?"
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Server won't start | Check logs: `bun run server-cli logs` |
+| MCP tools not available | Verify `~/.claude.json` has madeinoz-knowledge entry |
+| API errors (401) | Check API key is valid and has quota |
+| Neo4j connection errors | Verify `MADEINOZ_KNOWLEDGE_NEO4J_URI=bolt://neo4j:7687` in `~/.claude/.env` |
+| Env file has wrong URI | Run `bun run server-cli stop && bun run server-cli start` to regenerate env files |
+
+## Related
+
+- `INSTALL.md` - Full installation guide in pack root
+- `VERIFY.md` - Complete verification checklist
+- `diagnose.ts` - Diagnostic tool for troubleshooting