crukx-mcp 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# crukx-mcp
+
+Crukx MCP server — reliability control plane for autonomous software engineering.
+
+Connect Cursor, Claude Desktop, or any MCP-compatible IDE to the Crukx 7-agent swarm.
+
+## Install
+
+```bash
+npm install -g crukx-mcp
+```
+
+## Usage
+
+### Login
+```bash
+crukx login
+```
+
+### Add to Cursor / Claude Desktop
+
+```json
+{
+  "mcpServers": {
+    "crukx": {
+      "command": "crukx",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `swarm_audit` | Full 7-agent reliability audit |
+| `security_scan` | Targeted security analysis |
+| `reliability_score` | Quick reliability score |
+| `report_fetch` | Fetch audit report by ID |
+| `suggest_fix` | Remediation suggestions |
+| `crukx_health` | Check gateway connectivity |
+
+## Links
+
+- [crukx.dev](https://crukx.dev)
+- [GitHub](https://github.com/Shafwansafi06/observability-hub)

package/dist/bin/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/cli.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+import {
+  CONFIG_PATH,
+  clearAuth,
+  getConfig,
+  loadAuth,
+  saveAuth
+} from "../chunk-5FGEDZZW.js";
+
+// src/bin/cli.ts
+import { Command } from "commander";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { createInterface } from "readline";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { join, dirname as pathDirname } from "path";
+var __dirname = pathDirname(fileURLToPath(import.meta.url));
+var program = new Command();
+program.name("crukx").description("Crukx CLI \u2014 reliability control plane for autonomous software engineering").version("0.1.0");
+program.command("login").description("Authenticate with Crukx").option("--api-url <url>", "Crukx gateway URL", getConfig().CRUKX_API_URL).option("--workspace-id <id>", "Workspace ID").action(async (opts) => {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const ask = (q) => new Promise((r) => rl.question(q, r));
+  try {
+    const email = await ask("Email: ");
+    const password = await ask("Password: ");
+    const workspaceId = opts.workspaceId ?? await ask("Workspace ID: ");
+    rl.close();
+    process.stderr.write("Authenticating...\n");
+    const res = await fetch(`${opts.apiUrl}/v1/mcp/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password, workspace_id: workspaceId })
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      process.stderr.write(`Login failed: ${err.error ?? res.status}
+`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+    saveAuth({
+      access_token: data.access_token,
+      workspace_id: data.workspace_id,
+      expires_at: data.expires_at,
+      api_url: opts.apiUrl
+    });
+    process.stderr.write(`\u2705 Logged in. Config saved to ${CONFIG_PATH}
+`);
+  } catch (err) {
+    rl.close();
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Revoke current session").action(() => {
+  clearAuth();
+  process.stderr.write("Logged out.\n");
+});
+program.command("whoami").description("Show current auth status").action(() => {
+  const auth = loadAuth();
+  if (!auth?.access_token) {
+    process.stderr.write("Not logged in. Run: crukx login\n");
+    process.exit(1);
+  }
+  process.stdout.write(`Workspace: ${auth.workspace_id}
+Expires: ${auth.expires_at}
+API: ${auth.api_url}
+`);
+});
+program.command("mcp").description("Start the Crukx MCP server (stdio transport)").action(() => {
+  const serverPath = join(__dirname, "server.js");
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: "inherit",
+    env: process.env
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+});
+program.parse();

package/dist/chunk-5FGEDZZW.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+// src/config/index.ts
+import "dotenv/config";
+import { z } from "zod";
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
+var ConfigSchema = z.object({
+  CRUKX_API_URL: z.string().url().default("https://crukx-gateway.salmonisland-7ebc5692.centralindia.azurecontainerapps.io"),
+  CRUKX_ACCESS_TOKEN: z.string().optional(),
+  CRUKX_WORKSPACE_ID: z.string().optional()
+});
+function loadLocalConfig() {
+  const configPath = join(homedir(), ".crukx", "config.json");
+  if (!existsSync(configPath)) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getConfig() {
+  const local = loadLocalConfig();
+  return ConfigSchema.parse({ ...local, ...process.env });
+}
+var CONFIG_PATH = join(homedir(), ".crukx", "config.json");
+
+// src/auth/index.ts
+import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { dirname } from "path";
+function saveAuth(auth) {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  const existing = loadAuth() ?? {};
+  writeFileSync(CONFIG_PATH, JSON.stringify({ ...existing, ...auth }, null, 2));
+}
+function loadAuth() {
+  if (!existsSync2(CONFIG_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function clearAuth() {
+  if (existsSync2(CONFIG_PATH)) writeFileSync(CONFIG_PATH, "{}");
+}
+
+export {
+  getConfig,
+  CONFIG_PATH,
+  saveAuth,
+  loadAuth,
+  clearAuth
+};

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+import {
+  getConfig,
+  loadAuth
+} from "./chunk-5FGEDZZW.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/index.ts
+import { z as z2 } from "zod";
+
+// src/api/client.ts
+import { z } from "zod";
+import { randomUUID } from "crypto";
+var TIMEOUT_MS = 6e4;
+var AuditResultSchema = z.object({
+  auditId: z.string(),
+  findings: z.array(z.object({
+    id: z.string(),
+    rule: z.string(),
+    severity: z.enum(["critical", "high", "medium", "low", "info"]),
+    message: z.string(),
+    file: z.string(),
+    line: z.number(),
+    suggestion: z.string().optional(),
+    confidence: z.number(),
+    category: z.string()
+  })),
+  summary: z.object({
+    totalFindings: z.number(),
+    criticalCount: z.number(),
+    highCount: z.number(),
+    mediumCount: z.number(),
+    lowCount: z.number(),
+    infoCount: z.number(),
+    reliabilityScore: z.number(),
+    confidence: z.number()
+  }),
+  metadata: z.object({
+    processingTimeMs: z.number(),
+    agentsUsed: z.array(z.string()),
+    swarmId: z.string()
+  })
+});
+async function request(path, init = {}) {
+  const auth = loadAuth();
+  const cfg = getConfig();
+  const baseUrl = auth?.api_url ?? cfg.CRUKX_API_URL;
+  const token = auth?.access_token ?? cfg.CRUKX_ACCESS_TOKEN;
+  if (!token) throw new Error("Not authenticated. Run: crukx login");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    const res = await fetch(`${baseUrl}${path}`, {
+      ...init,
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        "X-Crukx-Source": "mcp",
+        ...init.headers
+      }
+    });
+    if (res.status === 401) throw new Error("Token expired or invalid. Run: crukx login");
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Crukx API ${res.status}: ${body}`);
+    }
+    return res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function swarmAudit(params) {
+  const auth = loadAuth();
+  const body = {
+    jobId: randomUUID(),
+    repository: { id: 0, owner: "mcp", name: "audit", fullName: "mcp/audit" },
+    pullRequest: {
+      number: 0,
+      headSha: randomUUID().replace(/-/g, "").slice(0, 40),
+      baseSha: randomUUID().replace(/-/g, "").slice(0, 40),
+      headRef: "main",
+      baseRef: "main",
+      title: params.focus ?? "MCP Audit"
+    },
+    diff: params.diff ?? `# Audit request
+focus: ${params.focus ?? "general"}
+path: ${params.repoPath ?? "."}`,
+    triggeredBy: "mcp",
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace_id: params.workspaceId ?? auth?.workspace_id
+  };
+  const raw = await request("/v1/mcp/swarm/audit", { method: "POST", body: JSON.stringify(body) });
+  return AuditResultSchema.parse(raw);
+}
+async function fetchReport(reportId) {
+  return request(`/v1/mcp/reports/${reportId}`);
+}
+async function healthCheck() {
+  return request("/v1/mcp/health");
+}
+
+// src/tools/index.ts
+function formatFindings(result) {
+  const { summary, findings, metadata } = result;
+  const grade = summary.reliabilityScore >= 90 ? "A" : summary.reliabilityScore >= 80 ? "B" : summary.reliabilityScore >= 70 ? "C" : "D";
+  const lines = [
+    `## Crukx Reliability Score: ${summary.reliabilityScore}/100 (Grade ${grade})`,
+    `Confidence: ${summary.confidence}% | Agents: ${metadata.agentsUsed.join(", ")} | Time: ${metadata.processingTimeMs}ms`,
+    ``,
+    `| Severity | Count |`,
+    `|----------|-------|`,
+    `| Critical | ${summary.criticalCount} |`,
+    `| High     | ${summary.highCount} |`,
+    `| Medium   | ${summary.mediumCount} |`,
+    `| Low      | ${summary.lowCount} |`,
+    `| Info     | ${summary.infoCount} |`
+  ];
+  if (findings.length > 0) {
+    lines.push("", "### Findings");
+    for (const f of findings.slice(0, 20)) {
+      lines.push(`- **[${f.severity.toUpperCase()}]** \`${f.file}:${f.line}\` \u2014 ${f.message}`);
+      if (f.suggestion) lines.push(`  > ${f.suggestion}`);
+    }
+    if (findings.length > 20) lines.push(`  ... and ${findings.length - 20} more`);
+  }
+  return lines.join("\n");
+}
+function registerTools(server2) {
+  server2.tool(
+    "swarm_audit",
+    "Run a full Crukx 7-agent swarm audit on code. Returns reliability score, findings, and recommendations.",
+    {
+      diff: z2.string().optional().describe("Unified diff or code snippet to audit"),
+      repoPath: z2.string().optional().describe("Repository path or name for context"),
+      focus: z2.string().optional().describe('Specific area to focus on (e.g. "security", "concurrency")')
+    },
+    async ({ diff, repoPath, focus }) => {
+      const result = await swarmAudit({ diff, repoPath, focus });
+      return { content: [{ type: "text", text: formatFindings(result) }] };
+    }
+  );
+  server2.tool(
+    "security_scan",
+    "Run a targeted security scan using the Red Teamer and Hunter agents.",
+    {
+      diff: z2.string().describe("Code diff or snippet to scan for security issues")
+    },
+    async ({ diff }) => {
+      const result = await swarmAudit({ diff, focus: "security vulnerabilities, injection attacks, secrets, authentication flaws" });
+      const secFindings = result.findings.filter((f) => f.category === "security" || f.severity === "critical" || f.severity === "high");
+      const lines = secFindings.length === 0 ? ["\u2705 No security issues detected."] : secFindings.map((f) => `- **[${f.severity.toUpperCase()}]** ${f.message}
+  File: \`${f.file}:${f.line}\`${f.suggestion ? `
+  Fix: ${f.suggestion}` : ""}`);
+      return { content: [{ type: "text", text: `## Security Scan Results
+
+${lines.join("\n")}` }] };
+    }
+  );
+  server2.tool(
+    "reliability_score",
+    "Get a reliability score for a code change without full findings detail.",
+    {
+      diff: z2.string().describe("Code diff to score")
+    },
+    async ({ diff }) => {
+      const result = await swarmAudit({ diff });
+      const { reliabilityScore, confidence, criticalCount, highCount } = result.summary;
+      const passed = criticalCount === 0 && highCount === 0;
+      const text = [
+        `**Score:** ${reliabilityScore}/100`,
+        `**Gate:** ${passed ? "\u2705 PASSED" : "\u274C FAILED"}`,
+        `**Confidence:** ${confidence}%`,
+        `**Critical:** ${criticalCount} | **High:** ${highCount}`
+      ].join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server2.tool(
+    "report_fetch",
+    "Fetch a previously generated Crukx audit report by ID.",
+    {
+      report_id: z2.string().uuid().describe("Audit run ID to fetch")
+    },
+    async ({ report_id }) => {
+      const report = await fetchReport(report_id);
+      return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "suggest_fix",
+    "Get remediation suggestions for a specific finding or code issue.",
+    {
+      issue: z2.string().describe("Description of the issue or paste the problematic code"),
+      severity: z2.enum(["critical", "high", "medium", "low"]).optional().describe("Severity level")
+    },
+    async ({ issue, severity }) => {
+      const focus = `remediation and fix suggestions for: ${issue}. Severity: ${severity ?? "unknown"}`;
+      const result = await swarmAudit({ diff: issue, focus });
+      const suggestions = result.findings.filter((f) => f.suggestion).map((f) => `- **${f.rule}**: ${f.suggestion}`).join("\n");
+      return {
+        content: [{
+          type: "text",
+          text: suggestions.length > 0 ? `## Remediation Suggestions
+
+${suggestions}` : "\u2705 No specific remediation needed \u2014 code looks clean."
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "crukx_health",
+    "Check Crukx gateway connectivity and authentication status.",
+    {},
+    async () => {
+      const result = await healthCheck();
+      return { content: [{ type: "text", text: `Crukx gateway: ${result.status} \u2705` }] };
+    }
+  );
+}
+
+// src/server.ts
+var server = new McpServer({
+  name: "crukx",
+  version: "0.1.0"
+});
+registerTools(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "crukx-mcp",
+  "version": "0.1.0",
+  "description": "Crukx MCP server — reliability control plane for autonomous software engineering",
+  "type": "module",
+  "main": "./dist/server.js",
+  "bin": {
+    "crukx": "./dist/bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": ["mcp", "crukx", "reliability", "ai", "llm", "code-review", "swarm"],
+  "author": "Crukx",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Shafwansafi06/observability-hub"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/server.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsup": "^8.1.0",
+    "tsx": "^4.15.0",
+    "typescript": "^5.4.5"
+  }
+}