@duckmind/deepquark-darwin-arm64 0.1.0

package/.deepquark/skills/bundled/knowledge-graph/server/diagnose.ts

@@ -0,0 +1,483 @@
+#!/usr/bin/env bun
+/**
+ * Madeinoz Knowledge System Diagnostics Script
+ *
+ * Checks installation and provides troubleshooting guidance.
+ * Performs comprehensive health checks on the system.
+ */
+
+import { createContainerManager } from '../lib/container';
+import { createConfigLoader } from '../lib/config';
+import { cli } from '../lib/cli';
+import { $ } from 'bun';
+
+/**
+ * Diagnostic check result
+ */
+interface CheckResult {
+  name: string;
+  passed: boolean;
+  message: string;
+  details?: string;
+}
+
+/**
+ * Diagnostics class
+ */
+class Diagnostics {
+  private issues = 0;
+  private results: CheckResult[] = [];
+
+  /**
+   * Add a check result
+   */
+  addResult(result: CheckResult): void {
+    this.results.push(result);
+    if (!result.passed) {
+      this.issues++;
+    }
+  }
+
+  /**
+   * Print a header
+   */
+  printHeader(title: string): void {
+    cli.blank();
+    cli.header(title, 50);
+    cli.blank();
+  }
+
+  /**
+   * Check 1: Podman Installation
+   */
+  async checkPodman(): Promise<void> {
+    this.printHeader('Check 1: Container Runtime');
+
+    try {
+      // Check if podman or docker is installed
+      const podmanCheck = await $`which podman`.quiet().nothrow();
+      const dockerCheck = await $`which docker`.quiet().nothrow();
+
+      if (podmanCheck.exitCode === 0) {
+        const version = await $`podman --version`.quiet();
+        this.addResult({
+          name: 'Container Runtime',
+          passed: true,
+          message: `Podman installed: ${version.stdout.toString().trim()}`,
+        });
+      } else if (dockerCheck.exitCode === 0) {
+        const version = await $`docker --version`.quiet();
+        this.addResult({
+          name: 'Container Runtime',
+          passed: true,
+          message: `Docker installed: ${version.stdout.toString().trim()}`,
+        });
+      } else {
+        this.addResult({
+          name: 'Container Runtime',
+          passed: false,
+          message: 'No container runtime found',
+          details: 'Install from: https://podman.io/getting-started/installation',
+        });
+      }
+    } catch {
+      this.addResult({
+        name: 'Container Runtime',
+        passed: false,
+        message: 'Error checking for container runtime',
+      });
+    }
+  }
+
+  /**
+   * Check 2: Configuration File
+   */
+  async checkConfig(): Promise<void> {
+    this.printHeader('Check 2: Configuration File');
+
+    const configLoader = createConfigLoader();
+
+    if (await configLoader.envExists()) {
+      this.addResult({
+        name: '.env File',
+        passed: true,
+        message: '.env file exists',
+      });
+
+      // Load and check for API keys
+      try {
+        const config = await configLoader.load();
+
+        // Check for API keys
+        const hasAnyKey =
+          !!config.OPENAI_API_KEY ||
+          !!config.ANTHROPIC_API_KEY ||
+          !!config.GOOGLE_API_KEY ||
+          !!config.GROQ_API_KEY;
+
+        if (hasAnyKey) {
+          const keyType = config.OPENAI_API_KEY
+            ? 'OpenAI'
+            : config.ANTHROPIC_API_KEY
+              ? 'Anthropic'
+              : config.GOOGLE_API_KEY
+                ? 'Google'
+                : 'Groq';
+          this.addResult({
+            name: 'API Key',
+            passed: true,
+            message: `${keyType} API key configured`,
+          });
+        } else {
+          this.addResult({
+            name: 'API Key',
+            passed: false,
+            message: 'No API keys found in .env',
+            details: 'Run: bun run src/skills/tools/install.ts',
+          });
+        }
+
+        // Check model configuration
+        this.addResult({
+          name: 'Model Configuration',
+          passed: true,
+          message: `Model: ${config.MODEL_NAME}`,
+        });
+
+        // Check semaphore limit
+        this.addResult({
+          name: 'Concurrency Limit',
+          passed: true,
+          message: `Semaphore limit: ${config.SEMAPHORE_LIMIT}`,
+        });
+      } catch (error) {
+        this.addResult({
+          name: '.env File',
+          passed: false,
+          message: 'Error loading .env file',
+          details: String(error),
+        });
+      }
+    } else {
+      this.addResult({
+        name: '.env File',
+        passed: false,
+        message: '.env file not found',
+        details: 'Run: bun run src/skills/tools/install.ts',
+      });
+    }
+  }
+
+  /**
+   * Check 3: Container Status
+   */
+  async checkContainers(): Promise<void> {
+    this.printHeader('Check 3: Container Status');
+
+    const containerManager = createContainerManager();
+
+    if (!containerManager.isRuntimeAvailable()) {
+      this.addResult({
+        name: 'Container Runtime',
+        passed: false,
+        message: 'Container runtime not available',
+      });
+      return;
+    }
+
+    const containerName = 'madeinoz-knowledge-graph-mcp';
+    const isRunning = await containerManager.isContainerRunning(containerName);
+
+    if (isRunning) {
+      this.addResult({
+        name: 'Container',
+        passed: true,
+        message: 'Container is running',
+      });
+
+      // Get container details
+      const info = await containerManager.getContainerInfo(containerName);
+      if (info.uptime) {
+        cli.dim(`  Status: ${info.uptime}`);
+      }
+      if (info.ports) {
+        cli.dim(`  Ports: ${info.ports}`);
+      }
+    } else {
+      const exists = await containerManager.containerExists(containerName);
+      if (exists) {
+        this.addResult({
+          name: 'Container',
+          passed: false,
+          message: 'Container exists but not running',
+          details: 'Start with: bun run src/server/run.ts',
+        });
+      } else {
+        this.addResult({
+          name: 'Container',
+          passed: false,
+          message: 'Container not found',
+          details: 'Run: bun run src/server/run.ts',
+        });
+      }
+    }
+  }
+
+  /**
+   * Check 4: Server Health
+   */
+  async checkServerHealth(): Promise<void> {
+    this.printHeader('Check 4: MCP Server Health');
+
+    try {
+      const response = await fetch('http://localhost:8000/health', {
+        signal: AbortSignal.timeout(5000),
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.status === 'healthy' || data.status === 'ok') {
+          this.addResult({
+            name: 'MCP Server',
+            passed: true,
+            message: 'MCP server is healthy',
+          });
+        } else {
+          this.addResult({
+            name: 'MCP Server',
+            passed: false,
+            message: 'Server responding but health check unclear',
+            details: `Response: ${JSON.stringify(data)}`,
+          });
+        }
+      } else {
+        this.addResult({
+          name: 'MCP Server',
+          passed: false,
+          message: `Server returned HTTP ${response.status}`,
+        });
+      }
+    } catch {
+      this.addResult({
+        name: 'MCP Server',
+        passed: false,
+        message: 'MCP server not responding',
+        details: 'Check logs: bun run src/server/logs.ts',
+      });
+    }
+  }
+
+  /**
+   * Check 5: PAI Skill Installation
+   */
+  async checkPAISkill(): Promise<void> {
+    this.printHeader('Check 5: PAI Skill Installation');
+
+    const possiblePaths = [
+      `${process.env.HOME}/.claude/skills/Knowledge`,
+      `${process.env.HOME}/.claude/skills/madeinoz-knowledge-system`,
+      process.env.PAI_DIR ? `${process.env.PAI_DIR}/skills/Knowledge` : '',
+      process.env.PAI_DIR ? `${process.env.PAI_DIR}/skills/madeinoz-knowledge-system` : '',
+    ].filter(Boolean);
+
+    let found = false;
+    for (const path of possiblePaths) {
+      try {
+        const file = Bun.file(path);
+        if (await file.exists()) {
+          this.addResult({
+            name: 'PAI Skill',
+            passed: true,
+            message: `PAI skill installed: ${path}`,
+          });
+          found = true;
+          break;
+        }
+      } catch {
+        // Continue
+      }
+    }
+
+    if (!found) {
+      this.addResult({
+        name: 'PAI Skill',
+        passed: false,
+        message: 'PAI skill not found in standard locations',
+        details: 'Install with: cp -r madeinoz-knowledge-system ~/.claude/skills/',
+      });
+    }
+  }
+
+  /**
+   * Check 6: Port Availability
+   */
+  async checkPorts(): Promise<void> {
+    this.printHeader('Check 6: Port Availability');
+
+    const ports = [
+      { port: 8000, description: 'MCP Server' },
+      { port: 6379, description: 'FalkorDB' },
+      { port: 3000, description: 'FalkorDB Web UI' },
+    ];
+
+    for (const { port, description } of ports) {
+      try {
+        // Try to bind to the port to check if it's available
+        const server = Bun.serve({
+          port,
+          fetch: () => new Response('OK'),
+        });
+
+        // Immediately stop the server
+        server.stop();
+
+        this.addResult({
+          name: `Port ${port}`,
+          passed: true,
+          message: `${description} (port ${port}) is available`,
+        });
+      } catch {
+        this.addResult({
+          name: `Port ${port}`,
+          passed: false,
+          message: `${description} (port ${port}) is in use`,
+        });
+      }
+    }
+  }
+
+  /**
+   * Check 7: Resource Usage
+   */
+  async checkResources(): Promise<void> {
+    this.printHeader('Check 7: Resource Usage');
+
+    const containerManager = createContainerManager();
+    const containerName = 'madeinoz-knowledge-graph-mcp';
+
+    if (await containerManager.isContainerRunning(containerName)) {
+      try {
+        const stats = await containerManager.getStats(containerName);
+        if (stats.success) {
+          this.addResult({
+            name: 'Resource Usage',
+            passed: true,
+            message: 'Container resource usage:',
+            details: stats.stdout,
+          });
+          console.log(stats.stdout);
+        }
+      } catch {
+        this.addResult({
+          name: 'Resource Usage',
+          passed: false,
+          message: 'Could not fetch resource stats',
+        });
+      }
+    } else {
+      this.addResult({
+        name: 'Resource Usage',
+        passed: false,
+        message: 'Container not running',
+      });
+    }
+  }
+
+  /**
+   * Print summary
+   */
+  printSummary(): void {
+    this.printHeader('Diagnostic Summary');
+
+    const _passed = this.results.filter((r) => r.passed).length;
+    const _total = this.results.length;
+
+    if (this.issues === 0) {
+      cli.success('✓ All checks passed! System is healthy.');
+      cli.blank();
+      cli.info('Your Madeinoz Knowledge System is ready to use.');
+      cli.blank();
+      cli.info('Try these commands:');
+      cli.dim("  Remember that I've successfully installed the Madeinoz Knowledge System.");
+      cli.dim('  What do I know about PAI?');
+      cli.dim('  Show the knowledge graph status');
+    } else {
+      cli.warning(`⚠ Found ${this.issues} issue(s) that need attention`);
+      cli.blank();
+      cli.info('Recommended actions:');
+
+      // Group recommendations by check type
+      for (const result of this.results) {
+        if (!result.passed && result.details) {
+          cli.dim(`  • ${result.message}: ${result.details}`);
+        }
+      }
+
+      // Additional contextual recommendations
+      const runtimeResult = this.results.find((r) => r.name === 'Container Runtime');
+      if (!runtimeResult?.passed) {
+        cli.blank();
+        cli.info('1. Install Podman');
+      }
+
+      const configResult = this.results.find((r) => r.name === '.env File');
+      if (!configResult?.passed) {
+        cli.blank();
+        cli.info('2. Run installation: bun run src/skills/tools/install.ts');
+      }
+
+      const containerResult = this.results.find((r) => r.name === 'Container');
+      if (!containerResult?.passed) {
+        cli.blank();
+        cli.info('3. Start the server: bun run src/server/run.ts');
+      }
+
+      const healthResult = this.results.find((r) => r.name === 'MCP Server');
+      if (!healthResult?.passed) {
+        cli.blank();
+        cli.info('4. Check logs: bun run src/server/logs.ts');
+      }
+    }
+
+    cli.blank();
+    cli.info('For more help, see:');
+    cli.dim('  - README.md');
+    cli.dim('  - INSTALL.md');
+    cli.dim('  - VERIFY.md');
+    cli.blank();
+  }
+
+  /**
+   * Run all checks
+   */
+  async run(): Promise<void> {
+    cli.clear();
+    cli.header('Madeinoz Knowledge System Diagnostics');
+    cli.blank();
+
+    await this.checkPodman();
+    await this.checkConfig();
+    await this.checkContainers();
+    await this.checkServerHealth();
+    await this.checkPAISkill();
+    await this.checkPorts();
+    await this.checkResources();
+
+    this.printSummary();
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const diagnostics = new Diagnostics();
+  await diagnostics.run();
+}
+
+// Run main function
+main().catch((error) => {
+  cli.error('Unexpected error:');
+  console.error(error);
+  process.exit(1);
+});

package/.deepquark/skills/bundled/knowledge-graph/server/docker-compose-falkordb-dev.yml

@@ -0,0 +1,146 @@
+# Docker Compose configuration for Madeinoz Knowledge System with FalkorDB backend - DEVELOPMENT
+# Isolated from production with different ports, volumes, and container names
+#
+# Usage:
+#   bun run server-cli start --dev     # Start dev environment (with DATABASE_TYPE=falkordb)
+#   bun run server-cli start           # Start production environment
+#
+# Access points:
+#   - FalkorDB Web UI: http://localhost:3001
+#   - MCP Server: http://localhost:8001
+#   - Prometheus Metrics: http://localhost:9091/metrics
+#   - Prometheus UI: http://localhost:9092
+#   - Grafana: http://localhost:3003 (admin/admin)
+#
+# Port Mapping (Dev vs Prod):
+#   Dev  -> Prod
+#   3001 -> 3000  (FalkorDB Web UI)
+#   8001 -> 8000  (MCP Server)
+#   9091 -> 9090  (Prometheus Metrics)
+#   9092 -> 9092  (Prometheus UI)
+#   3003 -> 3002  (Grafana - offset to avoid FalkorDB conflict)
+#
+# Volumes are prefixed with 'dev-' to isolate from production data
+
+name: madeinoz-knowledge-system-dev
+
+networks:
+  madeinoz-knowledge-dev-net:
+    driver: bridge
+
+volumes:
+  dev-falkordb-data:
+    driver: local
+  dev-prometheus-data:
+    driver: local
+  dev-grafana-data:
+    driver: local
+
+services:
+  # FalkorDB Graph Database (Development)
+  # Redis-based graph database
+  falkordb:
+    image: falkordb/falkordb:latest
+    container_name: madeinoz-knowledge-falkordb-dev
+    restart: unless-stopped
+    networks:
+      - madeinoz-knowledge-dev-net
+    ports:
+      - "3001:3000" # FalkorDB web UI (dev port)
+    volumes:
+      - dev-falkordb-data:/data
+    environment:
+      - FALKORDB_PASSWORD=
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 20s
+
+  # Graphiti MCP Server (Development - FalkorDB backend)
+  # Environment variables provided via env_file generated by server-cli.ts
+  graphiti-mcp:
+    image: madeinozknowledge-system:local
+    container_name: madeinoz-knowledge-graph-mcp-dev
+    restart: unless-stopped
+    networks:
+      - madeinoz-knowledge-dev-net
+    ports:
+      - "8001:8000" # MCP HTTP endpoint (dev port)
+      - "9091:9090" # Prometheus metrics endpoint (dev port)
+    env_file:
+      # Generated by server-cli.ts from MADEINOZ_KNOWLEDGE_* prefixed variables
+      - /tmp/madeinoz-knowledge-mcp-dev.env
+    environment:
+      # Logging: DEBUG for development (verbose output)
+      - LOG_LEVEL=DEBUG
+    depends_on:
+      falkordb:
+        condition: service_healthy
+    healthcheck:
+      test:
+        [
+          "CMD",
+          "curl",
+          "-sf",
+          "--max-time",
+          "5",
+          "http://localhost:8000/health",
+        ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # Prometheus Metrics Server (Development)
+  # Scrapes metrics from graphiti-mcp service
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: madeinoz-knowledge-prometheus-dev
+    restart: unless-stopped
+    networks:
+      - madeinoz-knowledge-dev-net
+    ports:
+      - "9092:9090" # Prometheus UI (dev port)
+    volumes:
+      - dev-prometheus-data:/prometheus
+      - ../../../config/monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+    command:
+      - "--config.file=/etc/prometheus/prometheus.yml"
+      - "--storage.tsdb.path=/prometheus"
+      - "--web.enable-lifecycle"
+      - "--storage.tsdb.retention.time=15d"
+    depends_on:
+      graphiti-mcp:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:9090/-/healthy"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+
+  # Grafana Dashboard (Development)
+  # Pre-configured with Prometheus datasource and dashboards
+  grafana:
+    image: grafana/grafana:latest
+    container_name: madeinoz-knowledge-grafana-dev
+    restart: unless-stopped
+    networks:
+      - madeinoz-knowledge-dev-net
+    ports:
+      - "3003:3000" # Grafana UI (dev port, offset to avoid FalkorDB UI conflict)
+    volumes:
+      - dev-grafana-data:/var/lib/grafana
+      - ../../../config/monitoring/grafana/provisioning/datasources:/etc/grafana/provisioning/datasources:ro
+      - ../../../config/monitoring/grafana/knowledge-system/dashboards:/etc/grafana/provisioning/dashboards:ro
+      - ../../../config/monitoring/grafana/knowledge-system/dashboards:/var/lib/grafana/dashboards:ro
+    environment:
+      - GF_SECURITY_ADMIN_USER=admin
+      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD:-admin}
+      - GF_USERS_ALLOW_SIGN_UP=false
+      - GF_SERVER_ROOT_URL=http://localhost:3003
+    depends_on:
+      prometheus:
+        condition: service_healthy