@cirvix_ai/agent-control 0.1.3 → 0.2.0

package/src/adapters/cursor.mjs

@@ -0,0 +1,104 @@
+/**
+ * Cursor Adapter for CIRVIX AgentControl.
+ *
+ * Supports:
+ * - ~/.cursor/mcp.json and project .cursor/mcp.json
+ * - .cursorrules and .cursor/rules/
+ * - Executable detection (cursor / cursor.cmd)
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+import { resolveExecutable } from "../core/windows.mjs";
+
+export class CursorAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "cursor",
+      label: "Cursor",
+      type: "editor",
+      mcpKey: "mcpServers",
+    });
+  }
+
+  async detect(cwd) {
+    const home = homedir();
+    const candidatePaths = [
+      join(cwd, ".cursor", "mcp.json"),
+      join(home, ".cursor", "mcp.json"),
+    ];
+
+    const existingPaths = [];
+    const servers = {};
+    let configFound = null;
+
+    for (const p of candidatePaths) {
+      if (await this.fileExists(p)) {
+        existingPaths.push(p);
+        const data = await this.readJson(p);
+        if (data) {
+          if (!configFound) configFound = data;
+          Object.assign(servers, data[this.mcpKey] ?? {});
+        }
+      }
+    }
+
+    const execPath = resolveExecutable("cursor", { cwd });
+    const hasRules = (await this.fileExists(join(cwd, ".cursorrules"))) || (await this.fileExists(join(cwd, ".cursor", "rules")));
+    const detected = existingPaths.length > 0 || Boolean(execPath) || hasRules;
+
+    const isIntegrated = Object.entries(servers).some(([name, def]) => this.isCirvixServer(name, def));
+
+    return {
+      detected,
+      paths: existingPaths,
+      targetConfigPath: existingPaths[0] ?? join(home, ".cursor", "mcp.json"),
+      config: configFound,
+      servers,
+      serverCount: Object.keys(servers).length,
+      isIntegrated,
+      hasConfig: existingPaths.length > 0,
+      executable: execPath,
+      metadata: {
+        hasRules,
+      },
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    const info = await this.detect(cwd);
+    const targetFile = info.targetConfigPath;
+    const currentServers = { ...info.servers };
+
+    const upstreams = {};
+    for (const [k, v] of Object.entries(currentServers)) {
+      if (!this.isCirvixServer(k, v)) upstreams[k] = v;
+    }
+
+    const cirvixServerDef = {
+      command: "cirvix",
+      args: ["gateway", "--servers", targetFile.replace(/\\/g, "/")],
+    };
+
+    const newConfig = {
+      ...(info.config || {}),
+      [this.mcpKey]: {
+        ...currentServers,
+        cirvix: cirvixServerDef,
+      },
+    };
+
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile,
+      canIntegrate: true,
+      currentServers,
+      upstreams,
+      plan: newConfig,
+      snippet: JSON.stringify({ [this.mcpKey]: { cirvix: cirvixServerDef } }, null, 2),
+      reason: "Routes Cursor MCP tool calls through the CIRVIX runtime governance gateway.",
+    };
+  }
+}

package/src/adapters/frameworks.mjs

@@ -0,0 +1,110 @@
+/**
+ * Autonomous Agent Frameworks Adapter for CIRVIX AgentControl.
+ *
+ * Inspects declared dependencies in package.json, requirements.txt, and pyproject.toml
+ * for agent frameworks:
+ * - LangChain / LangGraph
+ * - CrewAI
+ * - OpenAI Agents SDK
+ * - Vercel AI SDK
+ * - Anthropic SDK
+ * - AutoGen
+ * - Model Context Protocol SDK
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+
+const FRAMEWORK_SPECS = [
+  { id: "langchain", label: "LangChain / LangGraph", deps: ["langchain", "@langchain/core", "langgraph", "langchain-core"] },
+  { id: "crewai", label: "CrewAI", deps: ["crewai"] },
+  { id: "autogen", label: "AutoGen / AG2", deps: ["pyautogen", "autogen-agentchat", "autogen-core"] },
+  { id: "openai-agents", label: "OpenAI Agents SDK", deps: ["@openai/agents", "openai-agents"] },
+  { id: "vercel-ai", label: "Vercel AI SDK", deps: ["ai", "@ai-sdk/openai", "@ai-sdk/anthropic"] },
+  { id: "anthropic", label: "Anthropic SDK", deps: ["@anthropic-ai/sdk", "anthropic"] },
+  { id: "mcp-sdk", label: "MCP SDK", deps: ["@modelcontextprotocol/sdk", "mcp"] },
+];
+
+export class FrameworksAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "frameworks",
+      label: "Autonomous Agent Frameworks",
+      type: "framework",
+      mcpKey: "servers",
+    });
+  }
+
+  async detect(cwd) {
+    const hits = [];
+
+    // Check package.json
+    const pkg = await this.readJson(join(cwd, "package.json"));
+    if (pkg) {
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const spec of FRAMEWORK_SPECS) {
+        const found = spec.deps.find((d) => d in deps);
+        if (found) {
+          hits.push({
+            id: spec.id,
+            label: spec.label,
+            via: `package.json -> ${found}`,
+          });
+        }
+      }
+    }
+
+    // Check Python files
+    for (const file of ["requirements.txt", "pyproject.toml"]) {
+      const path = join(cwd, file);
+      if (!(await this.fileExists(path))) continue;
+      let text = "";
+      try {
+        text = await readFile(path, "utf8");
+      } catch {
+        continue;
+      }
+
+      for (const spec of FRAMEWORK_SPECS) {
+        if (hits.some((h) => h.id === spec.id)) continue;
+        const found = spec.deps.find((d) => new RegExp(`(^|[\\s"'=])${d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "m").test(text));
+        if (found) {
+          hits.push({
+            id: spec.id,
+            label: spec.label,
+            via: `${file} -> ${found}`,
+          });
+        }
+      }
+    }
+
+    return {
+      detected: hits.length > 0,
+      frameworks: hits,
+      paths: [],
+      targetConfigPath: null,
+      config: null,
+      servers: {},
+      serverCount: 0,
+      isIntegrated: false,
+      hasConfig: false,
+      executable: null,
+      metadata: { hits },
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile: null,
+      canIntegrate: false,
+      currentServers: {},
+      upstreams: {},
+      plan: null,
+      snippet: `import { guard } from "@cirvix_ai/agent-control/guard";\nconst governedTools = guard.wrap(myTools, { agent: "worker" });`,
+      reason: "Agent frameworks in application code are instrumented via guard.wrap(tools, { agent, rules }).",
+    };
+  }
+}

package/src/adapters/gemini-cli.mjs

@@ -0,0 +1,104 @@
+/**
+ * Gemini CLI Adapter for CIRVIX AgentControl.
+ *
+ * Supports:
+ * - ~/.gemini/settings.json, gemini.json, .gemini/mcp.json
+ * - Executable detection (gemini / gemini.cmd)
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+import { resolveExecutable } from "../core/windows.mjs";
+
+export class GeminiCliAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "gemini-cli",
+      label: "Gemini CLI",
+      type: "cli",
+      mcpKey: "mcpServers",
+    });
+  }
+
+  async detect(cwd) {
+    const home = homedir();
+    const candidatePaths = [
+      join(cwd, "gemini.json"),
+      join(cwd, ".gemini", "settings.json"),
+      join(cwd, ".gemini", "mcp.json"),
+      join(home, ".gemini", "settings.json"),
+      join(home, ".gemini", "mcp.json"),
+    ];
+
+    const existingPaths = [];
+    const servers = {};
+    let configFound = null;
+
+    for (const p of candidatePaths) {
+      if (await this.fileExists(p)) {
+        existingPaths.push(p);
+        const data = await this.readJson(p);
+        if (data) {
+          if (!configFound) configFound = data;
+          const map = data.mcpServers ?? data.servers ?? {};
+          Object.assign(servers, map);
+        }
+      }
+    }
+
+    const execPath = resolveExecutable("gemini", { cwd });
+    const detected = existingPaths.length > 0 || Boolean(execPath);
+
+    const isIntegrated = Object.entries(servers).some(([name, def]) => this.isCirvixServer(name, def));
+
+    return {
+      detected,
+      paths: existingPaths,
+      targetConfigPath: existingPaths[0] ?? join(home, ".gemini", "settings.json"),
+      config: configFound,
+      servers,
+      serverCount: Object.keys(servers).length,
+      isIntegrated,
+      hasConfig: existingPaths.length > 0,
+      executable: execPath,
+      metadata: {},
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    const info = await this.detect(cwd);
+    const targetFile = info.targetConfigPath;
+    const currentServers = { ...info.servers };
+
+    const upstreams = {};
+    for (const [k, v] of Object.entries(currentServers)) {
+      if (!this.isCirvixServer(k, v)) upstreams[k] = v;
+    }
+
+    const cirvixServerDef = {
+      command: "cirvix",
+      args: ["gateway", "--servers", targetFile.replace(/\\/g, "/")],
+    };
+
+    const newConfig = {
+      ...(info.config || {}),
+      [this.mcpKey]: {
+        ...currentServers,
+        cirvix: cirvixServerDef,
+      },
+    };
+
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile,
+      canIntegrate: true,
+      currentServers,
+      upstreams,
+      plan: newConfig,
+      snippet: JSON.stringify({ [this.mcpKey]: { cirvix: cirvixServerDef } }, null, 2),
+      reason: "Brokers Gemini CLI tool execution through CIRVIX runtime policy.",
+    };
+  }
+}

package/src/adapters/generic-mcp.mjs

@@ -0,0 +1,101 @@
+/**
+ * Generic MCP Adapter for CIRVIX AgentControl.
+ *
+ * Supports:
+ * - Arbitrary MCP configuration files (mcp.json, .mcp.json, servers.json)
+ * - Environment variables specifying MCP server definitions
+ * - Local and remote MCP servers over stdio or Streamable HTTP
+ */
+
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+
+export class GenericMcpAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "generic-mcp",
+      label: "Generic MCP Client",
+      type: "generic",
+      mcpKey: "mcpServers",
+    });
+  }
+
+  async detect(cwd) {
+    const candidatePaths = [
+      join(cwd, "mcp.json"),
+      join(cwd, ".mcp.json"),
+      join(cwd, "servers.json"),
+      join(cwd, "cirvix.servers.json"),
+    ];
+
+    const existingPaths = [];
+    const servers = {};
+    let configFound = null;
+
+    for (const p of candidatePaths) {
+      if (await this.fileExists(p)) {
+        existingPaths.push(p);
+        const data = await this.readJson(p);
+        if (data) {
+          if (!configFound) configFound = data;
+          const map = data.mcpServers ?? data.servers ?? data;
+          if (typeof map === "object" && !Array.isArray(map)) {
+            Object.assign(servers, map);
+          }
+        }
+      }
+    }
+
+    const detected = existingPaths.length > 0;
+    const isIntegrated = Object.entries(servers).some(([name, def]) => this.isCirvixServer(name, def));
+
+    return {
+      detected,
+      paths: existingPaths,
+      targetConfigPath: existingPaths[0] ?? join(cwd, "mcp.json"),
+      config: configFound,
+      servers,
+      serverCount: Object.keys(servers).length,
+      isIntegrated,
+      hasConfig: existingPaths.length > 0,
+      executable: null,
+      metadata: {},
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    const info = await this.detect(cwd);
+    const targetFile = info.targetConfigPath;
+    const currentServers = { ...info.servers };
+
+    const upstreams = {};
+    for (const [k, v] of Object.entries(currentServers)) {
+      if (!this.isCirvixServer(k, v)) upstreams[k] = v;
+    }
+
+    const cirvixServerDef = {
+      command: "cirvix",
+      args: ["gateway", "--servers", targetFile.replace(/\\/g, "/")],
+    };
+
+    const newConfig = {
+      ...(info.config || {}),
+      mcpServers: {
+        ...currentServers,
+        cirvix: cirvixServerDef,
+      },
+    };
+
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile,
+      canIntegrate: true,
+      currentServers,
+      upstreams,
+      plan: newConfig,
+      snippet: JSON.stringify({ mcpServers: { cirvix: cirvixServerDef } }, null, 2),
+      reason: "Universal gateway configuration for generic MCP clients.",
+    };
+  }
+}

package/src/adapters/index.mjs

@@ -0,0 +1,209 @@
+/**
+ * Universal Agent Adapter Registry & Fleet Coordinator for CIRVIX AgentControl.
+ *
+ * Coordinates detection, compatibility level verification, configuration
+ * generation, and request routing across all supported AI agent environments.
+ */
+
+import { join } from "node:path";
+import { BaseAgentAdapter, COMPATIBILITY_LEVEL } from "./base.mjs";
+import { ClaudeCodeAdapter } from "./claude-code.mjs";
+import { CursorAdapter } from "./cursor.mjs";
+import { WindsurfAdapter } from "./windsurf.mjs";
+import { ClineAdapter } from "./cline.mjs";
+import { RooCodeAdapter } from "./roo-code.mjs";
+import { CodexAdapter } from "./codex.mjs";
+import { GeminiCliAdapter } from "./gemini-cli.mjs";
+import { VSCodeAdapter } from "./vscode.mjs";
+import { GenericMcpAdapter } from "./generic-mcp.mjs";
+import { FrameworksAdapter } from "./frameworks.mjs";
+import { read as readJournal } from "../core/journal.mjs";
+
+export {
+  BaseAgentAdapter,
+  COMPATIBILITY_LEVEL,
+  ClaudeCodeAdapter,
+  CursorAdapter,
+  WindsurfAdapter,
+  ClineAdapter,
+  RooCodeAdapter,
+  CodexAdapter,
+  GeminiCliAdapter,
+  VSCodeAdapter,
+  GenericMcpAdapter,
+  FrameworksAdapter,
+};
+
+/**
+ * Returns instantiated adapters for all known agent environments.
+ */
+export function getAllAdapters() {
+  return [
+    new ClaudeCodeAdapter(),
+    new CursorAdapter(),
+    new WindsurfAdapter(),
+    new ClineAdapter(),
+    new RooCodeAdapter(),
+    new CodexAdapter(),
+    new GeminiCliAdapter(),
+    new VSCodeAdapter(),
+    new GenericMcpAdapter(),
+    new FrameworksAdapter(),
+  ];
+}
+
+/**
+ * Finds the adapter that handles a specific agent/runtime ID.
+ */
+export function getAdapter(id) {
+  const adapters = getAllAdapters();
+  return adapters.find((a) => a.id === id) ?? null;
+}
+
+/**
+ * Scans the machine and workspace for all agent runtimes, assessing their
+ * actual, measured compatibility and enforcement level.
+ *
+ * @param {string} cwd
+ * @param {object} [options]
+ * @param {string} [options.stateDir]
+ * @returns {Promise<{ runtimes: object[], frameworks: object[], mcpServers: object[], summary: object }>}
+ */
+export async function detectFleet(cwd = process.cwd(), { stateDir = join(cwd, ".cirvix") } = {}) {
+  const adapters = getAllAdapters();
+  const detectionPromises = adapters.map(async (adapter) => {
+    try {
+      const info = await adapter.detect(cwd);
+      return { adapter, info };
+    } catch {
+      return { adapter, info: { detected: false } };
+    }
+  });
+
+  const results = await Promise.all(detectionPromises);
+
+  // Read audit log to check for verified executions
+  let auditRecords = [];
+  try {
+    auditRecords = await readJournal(join(stateDir, "audit.jsonl"));
+  } catch {
+    auditRecords = [];
+  }
+
+  const agentsWithAudits = new Set(auditRecords.map((r) => r.agent).filter(Boolean));
+  const agentsWithVerifiedPermits = new Set(
+    auditRecords
+      .filter((r) => (r.verdict === "permit" || r.decision === "allow") && r.tool)
+      .map((r) => r.agent)
+      .filter(Boolean),
+  );
+
+  const detectedRuntimes = [];
+  let detectedFrameworks = [];
+  const serverMap = new Map();
+
+  for (const { adapter, info } of results) {
+    if (!info || !info.detected) continue;
+
+    if (adapter.id === "frameworks") {
+      detectedFrameworks = info.frameworks ?? [];
+      continue;
+    }
+
+    const hasAuditLogs = agentsWithAudits.has(adapter.id);
+    const hasVerifiedCall = agentsWithVerifiedPermits.has(adapter.id);
+
+    const level = await adapter.getCompatibilityLevel(
+      {
+        ...info,
+        hasAuditLogs,
+        hasVerifiedCall,
+      },
+      stateDir,
+    );
+
+    detectedRuntimes.push({
+      id: adapter.id,
+      label: adapter.label,
+      type: adapter.type,
+      path: info.paths?.[0] ?? info.targetConfigPath,
+      paths: info.paths ?? [],
+      targetConfigPath: info.targetConfigPath,
+      governed: info.isIntegrated,
+      isIntegrated: info.isIntegrated,
+      compatibilityLevel: level,
+      serverCount: info.serverCount ?? 0,
+      servers: info.servers ?? {},
+      executable: info.executable ?? null,
+      metadata: info.metadata ?? {},
+    });
+
+    // Aggregate MCP servers across runtimes
+    for (const [name, def] of Object.entries(info.servers ?? {})) {
+      if (adapter.isCirvixServer(name, def)) continue;
+      const transport = def?.url ? "http" : "stdio";
+      const command = def?.command ?? def?.url ?? "";
+      const key = `${name}::${command}`;
+      const existing = serverMap.get(key);
+      if (existing) {
+        if (!existing.runtimes.includes(adapter.label)) {
+          existing.runtimes.push(adapter.label);
+        }
+      } else {
+        serverMap.set(key, {
+          name,
+          transport,
+          command,
+          args: def?.args ?? [],
+          runtimes: [adapter.label],
+          envKeys: Object.keys(def?.env ?? {}),
+          scope: inferScope(def),
+        });
+      }
+    }
+  }
+
+  const flattenedServers = [...serverMap.values()];
+
+  const summary = {
+    totalDetected: detectedRuntimes.length,
+    integrated: detectedRuntimes.filter((r) => r.isIntegrated).length,
+    enforced: detectedRuntimes.filter((r) => r.compatibilityLevel === COMPATIBILITY_LEVEL.ENFORCED || r.compatibilityLevel === COMPATIBILITY_LEVEL.VERIFIED).length,
+    verified: detectedRuntimes.filter((r) => r.compatibilityLevel === COMPATIBILITY_LEVEL.VERIFIED).length,
+    mcpServerCount: flattenedServers.length,
+  };
+
+  return {
+    runtimes: detectedRuntimes,
+    frameworks: detectedFrameworks,
+    mcpServers: flattenedServers,
+    summary,
+  };
+}
+
+function inferScope(def) {
+  const args = def?.args ?? [];
+  const paths = args.filter((a) => typeof a === "string" && (a.startsWith("/") || /^[A-Za-z]:[\\/]/.test(a)));
+  if (paths.length === 0) return null;
+  const widest = paths.find((p) => p === "/" || /^[A-Za-z]:[\\/]?$/.test(p));
+  return { paths, broad: Boolean(widest), widest: widest ?? null };
+}
+
+/**
+ * Generates safe integration plans across all detected un-integrated agents.
+ */
+export async function generateFleetPlan(cwd = process.cwd(), options = {}) {
+  const { runtimes } = await detectFleet(cwd, options);
+  const plans = [];
+
+  for (const rt of runtimes) {
+    const adapter = getAdapter(rt.id);
+    if (!adapter) continue;
+    try {
+      const plan = await adapter.generateIntegrationPlan(cwd, options);
+      plans.push(plan);
+    } catch {}
+  }
+
+  return plans;
+}