@devshub198211/devguard 2.0.1

package/dist/chunk-4WCL5IUZ.js

@@ -0,0 +1,493 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+// src/ai/agent-schema.ts
+function cleanLLMOutput(raw) {
+  let s = raw.trim();
+  s = s.replace(/^```(?:json|JSON)?\s*/m, "").replace(/```\s*$/m, "").trim();
+  const openBrace = s.indexOf("{");
+  const openBracket = s.indexOf("[");
+  let startIdx = -1;
+  let openChar = "", closeChar = "";
+  if (openBrace === -1 && openBracket === -1) return s;
+  if (openBrace === -1) {
+    startIdx = openBracket;
+    openChar = "[";
+    closeChar = "]";
+  } else if (openBracket === -1) {
+    startIdx = openBrace;
+    openChar = "{";
+    closeChar = "}";
+  } else if (openBrace < openBracket) {
+    startIdx = openBrace;
+    openChar = "{";
+    closeChar = "}";
+  } else {
+    startIdx = openBracket;
+    openChar = "[";
+    closeChar = "]";
+  }
+  let depth = 0, inString = false, escape = false, end = -1;
+  for (let i = startIdx; i < s.length; i++) {
+    const ch = s[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escape = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === openChar) depth++;
+    else if (ch === closeChar) {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  return end !== -1 ? s.slice(startIdx, end + 1) : s;
+}
+function repairJSON(raw) {
+  let result = "";
+  let inString = false;
+  let escape = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (escape) {
+      result += ch;
+      escape = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      result += ch;
+      escape = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      result += ch;
+      continue;
+    }
+    if (inString) {
+      result += ch;
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < raw.length && /\s/.test(raw[j])) j++;
+      if (j < raw.length && (raw[j] === "}" || raw[j] === "]")) {
+        continue;
+      }
+    }
+    result += ch;
+  }
+  return result;
+}
+function parseSchema(schema, raw) {
+  const cleaned = cleanLLMOutput(raw);
+  try {
+    const parsed = JSON.parse(cleaned);
+    const r = schema.safeParse(parsed);
+    if (r.success) return { success: true, data: r.data, raw: cleaned, errors: [], attempts: 1 };
+    return { success: false, raw: cleaned, errors: r.errors.map((e) => (e.path ? e.path + ": " : "") + e.message), attempts: 1 };
+  } catch {
+    const repaired = repairJSON(cleaned);
+    if (repaired !== cleaned) {
+      try {
+        const parsed = JSON.parse(repaired);
+        const r = schema.safeParse(parsed);
+        if (r.success) return { success: true, data: r.data, raw: repaired, errors: [], attempts: 2 };
+        return { success: false, raw: repaired, errors: r.errors.map((e) => (e.path ? e.path + ": " : "") + e.message), attempts: 2 };
+      } catch {
+      }
+    }
+    return { success: false, errors: ["Could not parse LLM output as JSON"], attempts: 2 };
+  }
+}
+async function parseWithRetry(schema, promptFn, maxRetries = 3) {
+  let context = "Respond with valid JSON only. No markdown fences, no explanation, just the JSON.";
+  let totalAttempts = 0;
+  for (let i = 0; i <= maxRetries; i++) {
+    const raw = await promptFn(context);
+    totalAttempts++;
+    const result = parseSchema(schema, raw);
+    if (result.success) return { ...result, attempts: totalAttempts };
+    context = `Your response failed validation: ${result.errors.join("; ")}. Fix these and respond with valid JSON only.`;
+  }
+  return { success: false, errors: [`Max retries (${maxRetries}) exceeded`], attempts: totalAttempts };
+}
+
+// src/ai/mcp-server-kit.ts
+var ERR = { PARSE: -32700, INVALID: -32600, NOT_FOUND: -32601, PARAMS: -32602, INTERNAL: -32603 };
+var MAX_MESSAGE_SIZE = 10 * 1024 * 1024;
+var MAX_NAME_LENGTH = 256;
+var HANDLER_TIMEOUT_MS = 3e4;
+function validateToolInput(args, schema) {
+  if (typeof args !== "object" || args === null || Array.isArray(args)) {
+    return "Arguments must be an object";
+  }
+  if (schema.required) {
+    for (const req of schema.required) {
+      if (!(req in args) || args[req] === void 0 || args[req] === null) {
+        return `Missing required argument: ${req}`;
+      }
+    }
+  }
+  for (const [key, val] of Object.entries(args)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return `Invalid argument name: ${key}`;
+    }
+    const propSchema = schema.properties[key];
+    if (propSchema) {
+      const expectedType = propSchema.type;
+      if (expectedType === "string" && typeof val !== "string") return `Argument '${key}' must be a string`;
+      if (expectedType === "number" && typeof val !== "number") return `Argument '${key}' must be a number`;
+      if (expectedType === "boolean" && typeof val !== "boolean") return `Argument '${key}' must be a boolean`;
+      if (expectedType === "integer" && (typeof val !== "number" || !Number.isInteger(val))) return `Argument '${key}' must be an integer`;
+      if (propSchema.enum && !propSchema.enum.includes(val)) return `Argument '${key}' must be one of: ${propSchema.enum.join(", ")}`;
+    }
+  }
+  return null;
+}
+var MCPServerBuilder = class {
+  constructor(name, version = "1.0.0", description = "") {
+    this.name = name;
+    this.version = version;
+    this.description = description;
+    this.tools = /* @__PURE__ */ new Map();
+    this.resources = /* @__PURE__ */ new Map();
+    this.prompts = /* @__PURE__ */ new Map();
+    this.capabilities = {};
+    this.initialized = false;
+    if (!name || typeof name !== "string") throw new Error("Server name is required");
+  }
+  addTool(tool) {
+    if (!tool.name || typeof tool.name !== "string" || tool.name.length > MAX_NAME_LENGTH) throw new Error("Tool must have a valid name");
+    if (typeof tool.handler !== "function") throw new Error("Tool must have a handler function");
+    if (!tool.inputSchema || tool.inputSchema.type !== "object") throw new Error("Tool must have a valid inputSchema with type: 'object'");
+    this.tools.set(tool.name, tool);
+    this.capabilities.tools = {};
+    return this;
+  }
+  addResource(resource) {
+    if (!resource.uri || typeof resource.uri !== "string") throw new Error("Resource must have a URI");
+    if (typeof resource.fetch !== "function") throw new Error("Resource must have a fetch function");
+    this.resources.set(resource.uri, resource);
+    this.capabilities.resources = {};
+    return this;
+  }
+  addPrompt(prompt) {
+    if (!prompt.name || typeof prompt.name !== "string") throw new Error("Prompt must have a name");
+    if (typeof prompt.handler !== "function") throw new Error("Prompt must have a handler function");
+    this.prompts.set(prompt.name, prompt);
+    this.capabilities.prompts = {};
+    return this;
+  }
+  respond(id, result) {
+    return JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n";
+  }
+  error(id, code, message, data) {
+    return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message, data } }) + "\n";
+  }
+  /** Run a handler with a timeout */
+  async runWithTimeout(fn, timeoutMs) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new Error("Handler execution timeout")), timeoutMs);
+      fn().then(
+        (result) => {
+          clearTimeout(timer);
+          resolve2(result);
+        },
+        (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      );
+    });
+  }
+  async dispatch(req) {
+    const { id, method, params } = req;
+    if (req.jsonrpc !== "2.0") {
+      if (id !== null && id !== void 0) return this.error(id, ERR.INVALID, "Invalid JSON-RPC version \u2014 must be '2.0'");
+      return null;
+    }
+    if (typeof method !== "string" || method.length === 0) {
+      if (id !== null && id !== void 0) return this.error(id, ERR.INVALID, "Method must be a non-empty string");
+      return null;
+    }
+    if (method === "initialize") {
+      this.initialized = true;
+      return this.respond(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: this.capabilities,
+        serverInfo: { name: this.name, version: this.version },
+        instructions: this.description || void 0
+      });
+    }
+    if (method === "initialized") return null;
+    if (method === "ping") return this.respond(id, {});
+    if (method === "tools/list") {
+      return this.respond(id, {
+        tools: [...this.tools.values()].map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      });
+    }
+    if (method === "tools/call") {
+      const toolName = params?.name;
+      if (typeof toolName !== "string") return this.error(id, ERR.PARAMS, "Tool name is required");
+      const tool = this.tools.get(toolName);
+      if (!tool) return this.error(id, ERR.NOT_FOUND, `Tool not found: ${toolName}`);
+      const args = params?.arguments ?? {};
+      const validationError = validateToolInput(args, tool.inputSchema);
+      if (validationError) return this.error(id, ERR.PARAMS, validationError);
+      try {
+        const result = await this.runWithTimeout(
+          () => tool.handler(args, { progressToken: params?._meta?.progressToken }),
+          HANDLER_TIMEOUT_MS
+        );
+        const content = typeof result === "string" ? [{ type: "text", text: result }] : [{ type: "text", text: JSON.stringify(result) }];
+        return this.respond(id, { content, isError: false });
+      } catch (e) {
+        const msg = e?.message ?? String(e);
+        return this.respond(id, { content: [{ type: "text", text: msg.slice(0, 4096) }], isError: true });
+      }
+    }
+    if (method === "resources/list") {
+      return this.respond(id, {
+        resources: [...this.resources.values()].map((r) => ({
+          uri: r.uri,
+          name: r.name,
+          description: r.description,
+          mimeType: r.mimeType
+        }))
+      });
+    }
+    if (method === "resources/read") {
+      const uri = params?.uri;
+      if (typeof uri !== "string") return this.error(id, ERR.PARAMS, "Resource URI is required");
+      const resource = this.resources.get(uri);
+      if (!resource) return this.error(id, ERR.NOT_FOUND, `Resource not found: ${uri}`);
+      try {
+        const raw = await this.runWithTimeout(() => resource.fetch(), HANDLER_TIMEOUT_MS);
+        const content = typeof raw === "string" ? { uri: resource.uri, mimeType: resource.mimeType ?? "text/plain", text: raw } : { uri: resource.uri, mimeType: raw.mimeType ?? resource.mimeType ?? "text/plain", ...raw.text ? { text: raw.text } : { blob: raw.blob } };
+        return this.respond(id, { contents: [content] });
+      } catch (e) {
+        return this.error(id, ERR.INTERNAL, `Resource fetch failed: ${(e?.message ?? "Unknown error").slice(0, 1024)}`);
+      }
+    }
+    if (method === "prompts/list") {
+      return this.respond(id, {
+        prompts: [...this.prompts.values()].map((p) => ({ name: p.name, description: p.description, arguments: p.arguments }))
+      });
+    }
+    if (method === "prompts/get") {
+      const promptName = params?.name;
+      if (typeof promptName !== "string") return this.error(id, ERR.PARAMS, "Prompt name is required");
+      const prompt = this.prompts.get(promptName);
+      if (!prompt) return this.error(id, ERR.NOT_FOUND, `Prompt not found: ${promptName}`);
+      try {
+        const messages = await this.runWithTimeout(
+          () => prompt.handler(params?.arguments ?? {}),
+          HANDLER_TIMEOUT_MS
+        );
+        return this.respond(id, { description: prompt.description, messages });
+      } catch (e) {
+        return this.error(id, ERR.INTERNAL, `Prompt handler failed: ${(e?.message ?? "Unknown error").slice(0, 1024)}`);
+      }
+    }
+    if (id !== null && id !== void 0) return this.error(id, ERR.NOT_FOUND, `Method not found: ${method}`);
+    return null;
+  }
+  startStdio() {
+    process.stdin.setEncoding("utf-8");
+    let buf = "";
+    let processing = Promise.resolve();
+    process.stdin.on("data", (chunk) => {
+      buf += chunk;
+      if (buf.length > MAX_MESSAGE_SIZE) {
+        process.stdout.write(this.error(null, ERR.PARSE, "Message too large") + "\n");
+        buf = "";
+        return;
+      }
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        processing = processing.then(async () => {
+          let req;
+          try {
+            req = JSON.parse(trimmed);
+          } catch {
+            process.stdout.write(this.error(null, ERR.PARSE, "Parse error") + "\n");
+            return;
+          }
+          if (typeof req !== "object" || req === null || Array.isArray(req)) {
+            process.stdout.write(this.error(null, ERR.INVALID, "Request must be a JSON object") + "\n");
+            return;
+          }
+          try {
+            const response = await this.dispatch(req);
+            if (response) process.stdout.write(response);
+          } catch (e) {
+            const reqId = req?.id;
+            if (reqId !== null && reqId !== void 0) {
+              process.stdout.write(this.error(reqId, ERR.INTERNAL, (e?.message ?? "Internal error").slice(0, 1024)) + "\n");
+            }
+          }
+        });
+      }
+    });
+    process.stdin.on("end", () => process.exit(0));
+    process.stderr.write(`[devguard/mcp] "${this.name}" v${this.version} started
+`);
+  }
+};
+var FileSystemAdapter = class {
+  constructor(dir = ".devguard-memory") {
+    this.keyIndex = /* @__PURE__ */ new Map();
+    this.baseDir = path.resolve(dir);
+    if (!fs.existsSync(this.baseDir)) {
+      fs.mkdirSync(this.baseDir, { recursive: true });
+    }
+  }
+  getFilePath(agentId) {
+    const safeId = crypto.createHash("sha256").update(agentId).digest("hex");
+    return path.join(this.baseDir, `${safeId}.json`);
+  }
+  async save(agentId, entry) {
+    const file = this.getFilePath(agentId);
+    let history = [];
+    if (fs.existsSync(file)) {
+      try {
+        const raw = fs.readFileSync(file, "utf-8");
+        history = JSON.parse(raw);
+        if (!Array.isArray(history)) history = [];
+      } catch {
+        history = [];
+      }
+    }
+    history.push(entry);
+    const tmp = `${file}.tmp.${crypto.randomBytes(4).toString("hex")}`;
+    fs.writeFileSync(tmp, JSON.stringify(history, null, 2));
+    fs.renameSync(tmp, file);
+  }
+  async getHistory(agentId, limit = 50) {
+    const file = this.getFilePath(agentId);
+    if (!fs.existsSync(file)) return [];
+    try {
+      const raw = fs.readFileSync(file, "utf-8");
+      const history = JSON.parse(raw);
+      if (!Array.isArray(history)) return [];
+      return history.slice(-limit);
+    } catch {
+      return [];
+    }
+  }
+  async clear(agentId) {
+    const file = this.getFilePath(agentId);
+    if (fs.existsSync(file)) fs.unlinkSync(file);
+  }
+};
+var RedisAdapter = class {
+  constructor(redisClient) {
+    this.client = redisClient;
+  }
+  async save(agentId, entry) {
+    const key = `devguard:mem:${agentId}`;
+    await this.client.rPush(key, JSON.stringify(entry));
+    await this.client.lTrim(key, -100, -1);
+  }
+  async getHistory(agentId, limit = 50) {
+    const key = `devguard:mem:${agentId}`;
+    const raw = await this.client.lRange(key, -limit, -1);
+    return raw.map((r) => {
+      try {
+        return JSON.parse(r);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+  async clear(agentId) {
+    await this.client.del(`devguard:mem:${agentId}`);
+  }
+};
+var AgentMemory = class {
+  constructor(adapter) {
+    this.adapter = adapter ?? new FileSystemAdapter();
+  }
+  async track(agentId, role, content, metadata) {
+    const entry = {
+      id: crypto.randomUUID(),
+      role,
+      content,
+      metadata,
+      timestamp: Date.now()
+    };
+    await this.adapter.save(agentId, entry);
+    return entry;
+  }
+  async getContext(agentId, limit = 10) {
+    const history = await this.adapter.getHistory(agentId, limit);
+    return history.map((h) => `${h.role.toUpperCase()}: ${h.content}`).join("\n");
+  }
+  async clear(agentId) {
+    await this.adapter.clear(agentId);
+  }
+};
+var MAX_RECORDS = 5e3;
+var LLMBudget = class {
+  constructor(config) {
+    this.records = [];
+    this.totalCost = 0;
+    this.config = config;
+  }
+  track(usage) {
+    const record = {
+      ...usage,
+      id: crypto.randomUUID(),
+      timestamp: Date.now()
+    };
+    this.records.push(record);
+    this.totalCost += record.costUSD;
+    if (this.records.length > MAX_RECORDS) {
+      this.records.shift();
+    }
+    if (this.totalCost >= this.config.monthlyLimitUSD) {
+      console.warn(`[devguard] LLM Budget Exceeded: $${this.totalCost.toFixed(4)} / $${this.config.monthlyLimitUSD}`);
+    } else if (this.config.warnAtUSD && this.totalCost >= this.config.warnAtUSD) {
+      console.warn(`[devguard] LLM Budget Warning: $${this.totalCost.toFixed(4)} / $${this.config.monthlyLimitUSD}`);
+    }
+    return record;
+  }
+  getSummary() {
+    return {
+      totalCost: this.totalCost,
+      recordCount: this.records.length,
+      limit: this.config.monthlyLimitUSD,
+      remaining: Math.max(0, this.config.monthlyLimitUSD - this.totalCost),
+      isExceeded: this.totalCost >= this.config.monthlyLimitUSD
+    };
+  }
+  getHistory(limit = 100) {
+    return this.records.slice(-limit);
+  }
+  reset() {
+    this.records = [];
+    this.totalCost = 0;
+  }
+};
+
+export { AgentMemory, FileSystemAdapter, LLMBudget, MCPServerBuilder, RedisAdapter, cleanLLMOutput, parseSchema, parseWithRetry };