midnight-mcp 0.1.41 → 0.2.2

package/dist/chunk-HOWO4K5A.js

@@ -0,0 +1,2197 @@
+// src/db/vectorStore.ts
+import { ChromaClient } from "chromadb";
+
+// src/utils/config.ts
+import { z } from "zod";
+import dotenv from "dotenv";
+dotenv.config();
+var ConfigSchema = z.object({
+  // Mode: 'hosted' (default) or 'local'
+  mode: z.enum(["hosted", "local"]).default("hosted"),
+  // Hosted API URL (used when mode is 'hosted')
+  hostedApiUrl: z.string().default("https://midnight-mcp-api.midnightmcp.workers.dev"),
+  // GitHub
+  githubToken: z.string().optional(),
+  // Vector Database (only needed for local mode)
+  chromaUrl: z.string().default("http://localhost:8000"),
+  // Embeddings (only needed for local mode)
+  openaiApiKey: z.string().optional(),
+  embeddingModel: z.string().default("text-embedding-3-small"),
+  // Server
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  syncInterval: z.number().default(9e5),
+  // 15 minutes
+  port: z.number().default(3e3),
+  // Data directories
+  dataDir: z.string().default("./data"),
+  cacheDir: z.string().default("./cache")
+});
+function loadConfig() {
+  const isLocalMode2 = process.env.MIDNIGHT_LOCAL === "true" || process.env.OPENAI_API_KEY && process.env.CHROMA_URL;
+  const rawConfig = {
+    mode: isLocalMode2 ? "local" : "hosted",
+    hostedApiUrl: process.env.MIDNIGHT_API_URL,
+    githubToken: process.env.GITHUB_TOKEN,
+    chromaUrl: process.env.CHROMA_URL,
+    openaiApiKey: process.env.OPENAI_API_KEY,
+    embeddingModel: process.env.EMBEDDING_MODEL,
+    logLevel: process.env.LOG_LEVEL,
+    syncInterval: process.env.SYNC_INTERVAL ? parseInt(process.env.SYNC_INTERVAL) : void 0,
+    port: process.env.PORT ? parseInt(process.env.PORT) : void 0,
+    dataDir: process.env.DATA_DIR,
+    cacheDir: process.env.CACHE_DIR
+  };
+  const cleanConfig = Object.fromEntries(
+    Object.entries(rawConfig).filter(([_, v]) => v !== void 0)
+  );
+  return ConfigSchema.parse(cleanConfig);
+}
+var config = loadConfig();
+function isHostedMode() {
+  return config.mode === "hosted";
+}
+var DEFAULT_REPOSITORIES = [
+  // Core Language & SDK
+  {
+    owner: "midnightntwrk",
+    repo: "compact",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-js",
+    branch: "main",
+    patterns: ["**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Documentation
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-docs",
+    branch: "main",
+    patterns: ["**/*.md", "**/*.mdx"],
+    exclude: ["node_modules/**"]
+  },
+  // Example DApps
+  {
+    owner: "midnightntwrk",
+    repo: "example-counter",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "example-bboard",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.tsx", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "example-dex",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.tsx", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Developer Tools
+  {
+    owner: "midnightntwrk",
+    repo: "create-mn-app",
+    branch: "main",
+    patterns: ["**/*.ts", "**/*.md", "**/*.json"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-wallet",
+    branch: "main",
+    patterns: ["**/*.ts", "**/*.tsx", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Infrastructure
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-indexer",
+    branch: "main",
+    patterns: ["**/*.ts", "**/*.md", "**/*.rs"],
+    exclude: ["node_modules/**", "dist/**", "target/**"]
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-node-docker",
+    branch: "main",
+    patterns: ["**/*.md", "**/Dockerfile", "**/*.yml", "**/*.yaml"],
+    exclude: []
+  },
+  // APIs & Connectors
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-dapp-connector-api",
+    branch: "main",
+    patterns: ["**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Tooling
+  {
+    owner: "midnightntwrk",
+    repo: "compact-tree-sitter",
+    branch: "main",
+    patterns: ["**/*.js", "**/*.md", "**/*.scm"],
+    exclude: ["node_modules/**"]
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "setup-compact-action",
+    branch: "main",
+    patterns: ["**/*.ts", "**/*.js", "**/*.md", "**/*.yml", "**/*.yaml"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Community
+  {
+    owner: "midnightntwrk",
+    repo: "midnight-awesome-dapps",
+    branch: "main",
+    patterns: ["**/*.md"],
+    exclude: []
+  },
+  {
+    owner: "midnightntwrk",
+    repo: "contributor-hub",
+    branch: "main",
+    patterns: ["**/*.md"],
+    exclude: []
+  },
+  // Partner Libraries (OpenZeppelin)
+  {
+    owner: "OpenZeppelin",
+    repo: "compact-contracts",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "OpenZeppelin",
+    repo: "midnight-apps",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Official Partners (from awesome-dapps)
+  {
+    owner: "bricktowers",
+    repo: "midnight-seabattle",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "bricktowers",
+    repo: "midnight-identity",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "bricktowers",
+    repo: "midnight-rwa",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "MeshJS",
+    repo: "midnight-starter-template",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "midnames",
+    repo: "core",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Sea Battle Hackathon Winners (Feb 2025)
+  {
+    owner: "ErickRomeroDev",
+    repo: "naval-battle-game_v2",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.tsx", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "eddex",
+    repo: "midnight-sea-battle-hackathon",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Mini DApp Hackathon Winners (Sep 2025)
+  {
+    owner: "statera-protocol",
+    repo: "statera-protocol-midnight",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "nel349",
+    repo: "midnight-bank",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  {
+    owner: "Imdavyking",
+    repo: "zkbadge",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**"]
+  },
+  // Core Partner - PaimaStudios (Gaming Infrastructure)
+  {
+    owner: "PaimaStudios",
+    repo: "midnight-game-2",
+    branch: "main",
+    patterns: ["**/*.compact", "**/*.ts", "**/*.tsx", "**/*.js", "**/*.md"],
+    exclude: ["node_modules/**", "dist/**", "phaser/node_modules/**"]
+  },
+  {
+    owner: "PaimaStudios",
+    repo: "midnight-wasm-prover",
+    branch: "main",
+    patterns: ["**/*.rs", "**/*.ts", "**/*.md"],
+    exclude: ["target/**", "node_modules/**", "pkg/**"]
+  },
+  {
+    owner: "PaimaStudios",
+    repo: "midnight-batcher",
+    branch: "main",
+    patterns: ["**/*.rs", "**/*.ts", "**/*.md"],
+    exclude: ["target/**", "node_modules/**"]
+  },
+  {
+    owner: "PaimaStudios",
+    repo: "midnight-impact-rps-example",
+    branch: "main",
+    patterns: ["**/*.rs", "**/*.ts", "**/*.md"],
+    exclude: ["target/**", "node_modules/**", "www/pkg/**"]
+  }
+];
+
+// src/utils/logger.ts
+var mcpLogCallback = null;
+function setMCPLogCallback(callback) {
+  mcpLogCallback = callback;
+}
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level;
+  format;
+  service;
+  constructor(level = "info", format = "text", service = "midnight-mcp") {
+    this.level = level;
+    this.format = format;
+    this.service = service;
+  }
+  /**
+   * Set log format at runtime
+   */
+  setFormat(format) {
+    this.format = format;
+  }
+  /**
+   * Set log level at runtime
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  formatTextMessage(level, message, meta) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}`;
+  }
+  formatJsonMessage(level, message, meta) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      service: this.service
+    };
+    if (meta) {
+      entry.meta = meta;
+    }
+    return JSON.stringify(entry);
+  }
+  formatMessage(level, message, meta) {
+    if (this.format === "json") {
+      return this.formatJsonMessage(level, message, meta);
+    }
+    return this.formatTextMessage(level, message, meta);
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.error(this.formatMessage("debug", message, meta));
+    }
+    mcpLogCallback?.("debug", this.service, { message, ...meta });
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.error(this.formatMessage("info", message, meta));
+    }
+    mcpLogCallback?.("info", this.service, { message, ...meta });
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.error(this.formatMessage("warn", message, meta));
+    }
+    mcpLogCallback?.("warning", this.service, { message, ...meta });
+  }
+  error(message, meta) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message, meta));
+    }
+    mcpLogCallback?.("error", this.service, { message, ...meta });
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(context) {
+    return new ChildLogger(this, context);
+  }
+};
+var ChildLogger = class {
+  parent;
+  context;
+  constructor(parent, context) {
+    this.parent = parent;
+    this.context = context;
+  }
+  debug(message, meta) {
+    this.parent.debug(message, { ...this.context, ...meta });
+  }
+  info(message, meta) {
+    this.parent.info(message, { ...this.context, ...meta });
+  }
+  warn(message, meta) {
+    this.parent.warn(message, { ...this.context, ...meta });
+  }
+  error(message, meta) {
+    this.parent.error(message, { ...this.context, ...meta });
+  }
+};
+var logFormat = process.env.LOG_FORMAT === "json" ? "json" : "text";
+var logger = new Logger(config.logLevel, logFormat);
+
+// src/utils/errors.ts
+var MCPError = class extends Error {
+  code;
+  suggestion;
+  details;
+  constructor(message, code, suggestion, details) {
+    super(message);
+    this.name = "MCPError";
+    this.code = code;
+    this.suggestion = suggestion;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      error: this.message,
+      code: this.code,
+      suggestion: this.suggestion,
+      ...this.details && { details: this.details }
+    };
+  }
+};
+var ErrorCodes = {
+  RATE_LIMIT: "RATE_LIMIT_EXCEEDED",
+  NOT_FOUND: "RESOURCE_NOT_FOUND",
+  NETWORK: "NETWORK_ERROR",
+  INVALID_INPUT: "INVALID_INPUT",
+  UNKNOWN_REPO: "UNKNOWN_REPOSITORY",
+  PARSE_ERROR: "PARSE_ERROR",
+  CHROMADB_UNAVAILABLE: "CHROMADB_UNAVAILABLE",
+  OPENAI_UNAVAILABLE: "OPENAI_UNAVAILABLE",
+  MISSING_PARAM: "MISSING_PARAMETER",
+  INVALID_VERSION: "INVALID_VERSION",
+  SAMPLING_UNAVAILABLE: "SAMPLING_UNAVAILABLE"
+};
+var SelfCorrectionHints = {
+  UNKNOWN_REPO: (repo, validRepos) => ({
+    error: `Unknown repository: '${repo}'`,
+    code: ErrorCodes.UNKNOWN_REPO,
+    suggestion: `Try one of these instead: ${validRepos.slice(0, 8).join(", ")}`,
+    correction: {
+      invalidValue: repo,
+      validValues: validRepos,
+      parameterName: "repo"
+    }
+  }),
+  INVALID_VERSION: (version, example) => ({
+    error: `Invalid version format: '${version}'`,
+    code: ErrorCodes.INVALID_VERSION,
+    suggestion: `Version should be like '${example}'. Check available versions with midnight-get-version-info first.`,
+    correction: {
+      invalidValue: version,
+      expectedFormat: "v1.0.0 or 0.14.0",
+      example
+    }
+  }),
+  MISSING_REQUIRED_PARAM: (paramName, toolName) => ({
+    error: `Missing required parameter: '${paramName}'`,
+    code: ErrorCodes.MISSING_PARAM,
+    suggestion: `The '${paramName}' parameter is required for ${toolName}. Please provide it.`,
+    correction: {
+      missingParameter: paramName,
+      tool: toolName
+    }
+  }),
+  FILE_NOT_FOUND: (path, repo, similarPaths) => ({
+    error: `File not found: '${path}' in ${repo}`,
+    code: ErrorCodes.NOT_FOUND,
+    suggestion: similarPaths?.length ? `Did you mean: ${similarPaths.join(", ")}?` : `Check the file path. Use midnight-get-file with a different path or list directory contents first.`,
+    correction: {
+      invalidPath: path,
+      ...similarPaths && { suggestions: similarPaths }
+    }
+  }),
+  SAMPLING_NOT_AVAILABLE: (toolName) => ({
+    error: `Sampling capability not available`,
+    code: ErrorCodes.SAMPLING_UNAVAILABLE,
+    suggestion: `${toolName} requires a client that supports sampling (e.g., Claude Desktop). Use a non-AI alternative or switch clients.`,
+    alternatives: {
+      "midnight-generate-contract": "Use midnight-search-compact to find similar contracts as templates",
+      "midnight-review-contract": "Use midnight-analyze-contract for static analysis",
+      "midnight-document-contract": "Manual documentation or inline comments"
+    }
+  }),
+  RATE_LIMIT: (retryAfter) => ({
+    error: "GitHub API rate limit exceeded",
+    code: ErrorCodes.RATE_LIMIT,
+    suggestion: retryAfter ? `Wait ${retryAfter} seconds before retrying. Or add GITHUB_TOKEN for higher limits.` : "Add GITHUB_TOKEN to increase from 60 to 5000 requests/hour.",
+    correction: {
+      action: "wait_and_retry",
+      ...retryAfter && { retryAfterSeconds: retryAfter }
+    }
+  })
+};
+function createUserError(error, context) {
+  const message = error instanceof Error ? error.message : String(error);
+  const ctx = context ? ` while ${context}` : "";
+  if (message.includes("rate limit") || message.includes("403") || message.includes("API rate limit")) {
+    return new MCPError(
+      `GitHub API rate limit exceeded${ctx}`,
+      ErrorCodes.RATE_LIMIT,
+      "Add GITHUB_TOKEN to your config to increase limits from 60 to 5000 requests/hour. Get a token at https://github.com/settings/tokens"
+    );
+  }
+  if (message.includes("404") || message.includes("Not Found")) {
+    return new MCPError(
+      `Resource not found${ctx}`,
+      ErrorCodes.NOT_FOUND,
+      "Check that the repository, file, or version exists and is publicly accessible."
+    );
+  }
+  if (message.includes("network") || message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("timeout")) {
+    return new MCPError(
+      `Network error${ctx}`,
+      ErrorCodes.NETWORK,
+      "Check your internet connection and try again. If the problem persists, the service may be temporarily unavailable."
+    );
+  }
+  if (message.includes("chroma") || message.includes("8000")) {
+    return new MCPError(
+      `ChromaDB is not available${ctx}`,
+      ErrorCodes.CHROMADB_UNAVAILABLE,
+      "ChromaDB is optional. Without it, search uses keyword matching instead of semantic search. To enable semantic search, run: docker run -d -p 8000:8000 chromadb/chroma"
+    );
+  }
+  if (message.includes("openai") || message.includes("embedding")) {
+    return new MCPError(
+      `OpenAI API error${ctx}`,
+      ErrorCodes.OPENAI_UNAVAILABLE,
+      "OpenAI is optional. Without it, search uses keyword matching. To enable semantic search, add OPENAI_API_KEY to your config."
+    );
+  }
+  return new MCPError(
+    `An error occurred${ctx}`,
+    "UNKNOWN_ERROR",
+    "If this problem persists, please report it at https://github.com/Olanetsoft/midnight-mcp/issues"
+  );
+}
+function formatErrorResponse(error, context) {
+  const mcpError = error instanceof MCPError ? error : createUserError(error, context);
+  return mcpError.toJSON();
+}
+
+// src/utils/validation.ts
+var MAX_LENGTHS = {
+  query: 1e3,
+  path: 500,
+  repository: 100,
+  ref: 100,
+  generic: 500
+};
+var DANGEROUS_PATTERNS = [
+  /[<>]/g,
+  // HTML/XML injection
+  /javascript:/gi,
+  // JS protocol
+  /data:/gi,
+  // Data URLs
+  /\0/g,
+  // Null bytes
+  /[\x00-\x08\x0B\x0C\x0E-\x1F]/g
+  // Control characters (except newline, tab)
+];
+function sanitizeString(input, maxLength = MAX_LENGTHS.generic) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  let sanitized = input;
+  for (const pattern of DANGEROUS_PATTERNS) {
+    sanitized = sanitized.replace(pattern, "");
+  }
+  sanitized = sanitized.trim();
+  if (sanitized.length > maxLength) {
+    sanitized = sanitized.substring(0, maxLength);
+  }
+  return sanitized;
+}
+function validateQuery(query) {
+  const warnings = [];
+  const errors = [];
+  if (query === null || query === void 0) {
+    return {
+      isValid: false,
+      sanitized: "",
+      warnings,
+      errors: ["Query is required"]
+    };
+  }
+  if (typeof query !== "string") {
+    return {
+      isValid: false,
+      sanitized: "",
+      warnings,
+      errors: ["Query must be a string"]
+    };
+  }
+  const sanitized = sanitizeString(query, MAX_LENGTHS.query);
+  if (sanitized.length === 0) {
+    errors.push("Query cannot be empty after sanitization");
+  }
+  if (sanitized.length < 2) {
+    warnings.push("Query is very short, results may be limited");
+  }
+  if (query.length !== sanitized.length) {
+    warnings.push(
+      "Query was sanitized to remove potentially dangerous characters"
+    );
+  }
+  return {
+    isValid: errors.length === 0,
+    sanitized,
+    warnings,
+    errors
+  };
+}
+function validateNumber(value, options) {
+  const { min = 1, max = 100, defaultValue } = options;
+  if (value === null || value === void 0) {
+    return { isValid: true, value: defaultValue };
+  }
+  const num = typeof value === "string" ? parseInt(value, 10) : value;
+  if (typeof num !== "number" || isNaN(num)) {
+    return {
+      isValid: false,
+      value: defaultValue,
+      error: "Must be a valid number"
+    };
+  }
+  if (num < min) {
+    return { isValid: true, value: min };
+  }
+  if (num > max) {
+    return { isValid: true, value: max };
+  }
+  return { isValid: true, value: num };
+}
+
+// src/pipeline/github.ts
+import { Octokit } from "octokit";
+var RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4
+};
+async function withRetry(operation, operationName) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      const isRetryable = isRetryableError(error);
+      if (!isRetryable || attempt === RETRY_CONFIG.maxRetries) {
+        logger.error(`${operationName} failed after ${attempt} attempt(s)`, {
+          error: String(error),
+          attempt
+        });
+        throw enhanceError(error, operationName);
+      }
+      const delay = Math.min(
+        RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1),
+        RETRY_CONFIG.maxDelayMs
+      );
+      logger.warn(`${operationName} failed, retrying in ${delay}ms...`, {
+        attempt,
+        error: String(error)
+      });
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function isRetryableError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return message.includes("network") || message.includes("timeout") || message.includes("econnreset") || message.includes("rate limit") || message.includes("403") || message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504");
+  }
+  return false;
+}
+function enhanceError(error, operation) {
+  const originalMessage = error instanceof Error ? error.message : String(error);
+  if (originalMessage.includes("rate limit") || originalMessage.includes("403")) {
+    return new Error(
+      `GitHub API rate limit exceeded during ${operation}. Add a GITHUB_TOKEN to your config to increase limits from 60 to 5000 requests/hour.`
+    );
+  }
+  if (originalMessage.includes("404")) {
+    return new Error(
+      `Resource not found during ${operation}. Check that the repository/file exists and is accessible.`
+    );
+  }
+  if (originalMessage.includes("timeout") || originalMessage.includes("network")) {
+    return new Error(
+      `Network error during ${operation}. Check your internet connection and try again.`
+    );
+  }
+  return new Error(`${operation} failed: ${originalMessage}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var SimpleCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMinutes = 10) {
+    this.ttlMs = ttlMinutes * 60 * 1e3;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.ttlMs) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  set(key, data) {
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var GitHubClient = class {
+  octokit;
+  fileCache = new SimpleCache(15);
+  // 15 min cache for files
+  treeCache = new SimpleCache(10);
+  // 10 min cache for trees
+  repoInfoCache = new SimpleCache(10);
+  // 10 min cache for repo info
+  constructor(token) {
+    this.octokit = new Octokit({
+      auth: token || config.githubToken,
+      request: {
+        timeout: 1e4
+        // 10 second timeout for API calls
+      }
+    });
+  }
+  /**
+   * Get repository information
+   */
+  async getRepositoryInfo(owner, repo) {
+    const cacheKey = `repo:${owner}/${repo}`;
+    const cached = this.repoInfoCache.get(cacheKey);
+    if (cached) {
+      logger.debug(`Cache hit for repo info: ${cacheKey}`);
+      return cached;
+    }
+    try {
+      const { data: repoData } = await withRetry(
+        () => this.octokit.rest.repos.get({ owner, repo }),
+        `getRepositoryInfo(${owner}/${repo})`
+      );
+      const { data: commits } = await withRetry(
+        () => this.octokit.rest.repos.listCommits({ owner, repo, per_page: 1 }),
+        `getCommits(${owner}/${repo})`
+      );
+      const lastCommit = commits[0] ? {
+        sha: commits[0].sha,
+        message: commits[0].commit.message,
+        author: commits[0].commit.author?.name || "Unknown",
+        date: commits[0].commit.author?.date || "",
+        url: commits[0].html_url
+      } : null;
+      const result = {
+        owner,
+        repo,
+        branch: repoData.default_branch,
+        lastCommit,
+        fileCount: 0
+        // Will be updated during tree fetch
+      };
+      this.repoInfoCache.set(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error(`Failed to get repository info for ${owner}/${repo}`, {
+        error: String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Get file content from a repository
+   */
+  async getFileContent(owner, repo, path, ref) {
+    const cacheKey = `file:${owner}/${repo}/${path}@${ref || "main"}`;
+    const cached = this.fileCache.get(cacheKey);
+    if (cached) {
+      logger.debug(`Cache hit for file: ${cacheKey}`);
+      return cached;
+    }
+    try {
+      const { data } = await withRetry(
+        () => this.octokit.rest.repos.getContent({ owner, repo, path, ref }),
+        `getFileContent(${owner}/${repo}/${path})`
+      );
+      if (Array.isArray(data) || data.type !== "file") {
+        return null;
+      }
+      const content = data.encoding === "base64" ? Buffer.from(data.content, "base64").toString("utf-8") : data.content;
+      const result = {
+        path: data.path,
+        content,
+        sha: data.sha,
+        size: data.size,
+        encoding: data.encoding
+      };
+      this.fileCache.set(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.warn(`Failed to get file ${path} from ${owner}/${repo}`, {
+        error: String(error)
+      });
+      return null;
+    }
+  }
+  /**
+   * Get repository tree (list of all files)
+   */
+  async getRepositoryTree(owner, repo, ref) {
+    const cacheKey = `tree:${owner}/${repo}@${ref || "main"}`;
+    const cached = this.treeCache.get(cacheKey);
+    if (cached) {
+      logger.debug(`Cache hit for tree: ${cacheKey}`);
+      return cached;
+    }
+    try {
+      const { data: refData } = await withRetry(
+        () => this.octokit.rest.git.getRef({
+          owner,
+          repo,
+          ref: `heads/${ref || "main"}`
+        }),
+        `getRef(${owner}/${repo})`
+      );
+      const { data: treeData } = await withRetry(
+        () => this.octokit.rest.git.getTree({
+          owner,
+          repo,
+          tree_sha: refData.object.sha,
+          recursive: "true"
+        }),
+        `getTree(${owner}/${repo})`
+      );
+      const result = treeData.tree.filter((item) => item.type === "blob" && item.path).map((item) => item.path);
+      this.treeCache.set(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error(`Failed to get repository tree for ${owner}/${repo}`, {
+        error: String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Filter files by patterns
+   */
+  filterFilesByPatterns(files, patterns, exclude) {
+    const matchPattern = (file, pattern) => {
+      const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\./g, "\\.");
+      return new RegExp(`^${regexPattern}$`).test(file);
+    };
+    return files.filter((file) => {
+      const matchesInclude = patterns.some((p) => matchPattern(file, p));
+      const matchesExclude = exclude.some((p) => matchPattern(file, p));
+      return matchesInclude && !matchesExclude;
+    });
+  }
+  /**
+   * Fetch all files from a repository matching patterns
+   */
+  async fetchRepositoryFiles(repoConfig) {
+    const { owner, repo, branch, patterns, exclude } = repoConfig;
+    logger.info(`Fetching files from ${owner}/${repo}...`);
+    const allFiles = await this.getRepositoryTree(owner, repo, branch);
+    const filteredFiles = this.filterFilesByPatterns(
+      allFiles,
+      patterns,
+      exclude
+    );
+    logger.info(
+      `Found ${filteredFiles.length} matching files in ${owner}/${repo}`
+    );
+    const files = [];
+    for (const filePath of filteredFiles) {
+      const file = await this.getFileContent(owner, repo, filePath, branch);
+      if (file) {
+        files.push(file);
+      }
+    }
+    return files;
+  }
+  /**
+   * Get recent commits
+   */
+  async getRecentCommits(owner, repo, since, perPage = 30) {
+    try {
+      const params = {
+        owner,
+        repo,
+        per_page: perPage
+      };
+      if (since) {
+        params.since = since;
+      }
+      const { data } = await this.octokit.rest.repos.listCommits(params);
+      return data.map((commit) => ({
+        sha: commit.sha,
+        message: commit.commit.message,
+        author: commit.commit.author?.name || "Unknown",
+        date: commit.commit.author?.date || "",
+        url: commit.html_url
+      }));
+    } catch (error) {
+      logger.error(`Failed to get commits for ${owner}/${repo}`, {
+        error: String(error)
+      });
+      return [];
+    }
+  }
+  /**
+   * Get files changed in recent commits
+   */
+  async getChangedFiles(owner, repo, since) {
+    try {
+      const commits = await this.getRecentCommits(owner, repo, since);
+      const changedFiles = /* @__PURE__ */ new Set();
+      for (const commit of commits) {
+        const { data } = await this.octokit.rest.repos.getCommit({
+          owner,
+          repo,
+          ref: commit.sha
+        });
+        data.files?.forEach((file) => {
+          if (file.filename) {
+            changedFiles.add(file.filename);
+          }
+        });
+      }
+      return Array.from(changedFiles);
+    } catch (error) {
+      logger.error(`Failed to get changed files for ${owner}/${repo}`, {
+        error: String(error)
+      });
+      return [];
+    }
+  }
+  /**
+   * Search code in repositories
+   */
+  async searchCode(query, owner, repo, language) {
+    try {
+      let q = query;
+      if (owner && repo) {
+        q += ` repo:${owner}/${repo}`;
+      } else if (owner) {
+        q += ` user:${owner}`;
+      }
+      if (language) {
+        q += ` language:${language}`;
+      }
+      const { data } = await this.octokit.rest.search.code({
+        q,
+        per_page: 30
+      });
+      return data.items.map((item) => ({
+        path: item.path,
+        repository: item.repository.full_name,
+        url: item.html_url
+      }));
+    } catch (error) {
+      logger.warn(`Code search failed for query: ${query}`, {
+        error: String(error)
+      });
+      return [];
+    }
+  }
+  /**
+   * Get current rate limit status from GitHub API
+   */
+  async getRateLimit() {
+    try {
+      const { data } = await this.octokit.rest.rateLimit.get();
+      const rateLimit = {
+        limit: data.rate.limit,
+        remaining: data.rate.remaining,
+        reset: new Date(data.rate.reset * 1e3),
+        used: data.rate.used
+      };
+      updateRateLimit(rateLimit);
+      return rateLimit;
+    } catch (error) {
+      logger.warn("Failed to get rate limit", { error: String(error) });
+      return {
+        limit: 60,
+        remaining: 60,
+        reset: new Date(Date.now() + 36e5),
+        used: 0
+      };
+    }
+  }
+  /**
+   * Check if it's safe to make API requests
+   */
+  checkRateLimit() {
+    const check = shouldProceedWithRequest();
+    const status = getRateLimitStatus();
+    if (!check.proceed) {
+      logger.warn("Rate limit check failed", { reason: check.reason });
+    }
+    return {
+      proceed: check.proceed,
+      reason: check.reason,
+      status
+    };
+  }
+};
+var githubClient = new GitHubClient();
+
+// src/pipeline/parser.ts
+function parseCompactFile(path, content) {
+  const lines = content.split("\n");
+  const codeUnits = [];
+  const imports = [];
+  const exports = [];
+  let hasLedger = false;
+  let hasCircuits = false;
+  let hasWitnesses = false;
+  const importRegex = /^include\s+["']([^"']+)["'];?/gm;
+  let importMatch;
+  while ((importMatch = importRegex.exec(content)) !== null) {
+    imports.push(importMatch[1]);
+  }
+  const ledgerRegex = /ledger\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gs;
+  let ledgerMatch;
+  while ((ledgerMatch = ledgerRegex.exec(content)) !== null) {
+    hasLedger = true;
+    const ledgerContent = ledgerMatch[1];
+    const startLine = content.substring(0, ledgerMatch.index).split("\n").length;
+    const endLine = startLine + ledgerMatch[0].split("\n").length - 1;
+    codeUnits.push({
+      type: "ledger",
+      name: "ledger",
+      code: ledgerMatch[0],
+      startLine,
+      endLine,
+      isPublic: true,
+      isPrivate: false
+    });
+    const fieldRegex = /(@private\s+)?(\w+)\s*:\s*([^;]+);/g;
+    let fieldMatch;
+    while ((fieldMatch = fieldRegex.exec(ledgerContent)) !== null) {
+      const isPrivate = !!fieldMatch[1];
+      codeUnits.push({
+        type: "ledger",
+        name: fieldMatch[2],
+        code: fieldMatch[0].trim(),
+        startLine,
+        endLine: startLine,
+        isPublic: !isPrivate,
+        isPrivate,
+        returnType: fieldMatch[3].trim()
+      });
+    }
+  }
+  const circuitRegex = /(export\s+)?circuit\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*(\w+))?\s*\{/g;
+  let circuitMatch;
+  while ((circuitMatch = circuitRegex.exec(content)) !== null) {
+    hasCircuits = true;
+    const isExport = !!circuitMatch[1];
+    const name = circuitMatch[2];
+    const params = circuitMatch[3];
+    const returnType = circuitMatch[4] || "Void";
+    const startIndex = circuitMatch.index;
+    let braceCount = 1;
+    let endIndex = content.indexOf("{", startIndex) + 1;
+    while (braceCount > 0 && endIndex < content.length) {
+      if (content[endIndex] === "{") braceCount++;
+      if (content[endIndex] === "}") braceCount--;
+      endIndex++;
+    }
+    const circuitCode = content.substring(startIndex, endIndex);
+    const startLine = content.substring(0, startIndex).split("\n").length;
+    const endLine = startLine + circuitCode.split("\n").length - 1;
+    const parameters = params.split(",").filter((p) => p.trim()).map((p) => {
+      const parts = p.trim().split(":");
+      return {
+        name: parts[0]?.trim() || "",
+        type: parts[1]?.trim() || "unknown"
+      };
+    });
+    if (isExport) {
+      exports.push(name);
+    }
+    codeUnits.push({
+      type: "circuit",
+      name,
+      code: circuitCode,
+      startLine,
+      endLine,
+      isPublic: isExport,
+      isPrivate: false,
+      parameters,
+      returnType
+    });
+  }
+  const witnessRegex = /witness\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^{]+))?\s*\{/g;
+  let witnessMatch;
+  while ((witnessMatch = witnessRegex.exec(content)) !== null) {
+    hasWitnesses = true;
+    const name = witnessMatch[1];
+    const params = witnessMatch[2];
+    const returnType = witnessMatch[3]?.trim() || "unknown";
+    const startIndex = witnessMatch.index;
+    let braceCount = 1;
+    let endIndex = content.indexOf("{", startIndex) + 1;
+    while (braceCount > 0 && endIndex < content.length) {
+      if (content[endIndex] === "{") braceCount++;
+      if (content[endIndex] === "}") braceCount--;
+      endIndex++;
+    }
+    const witnessCode = content.substring(startIndex, endIndex);
+    const startLine = content.substring(0, startIndex).split("\n").length;
+    const endLine = startLine + witnessCode.split("\n").length - 1;
+    const parameters = params.split(",").filter((p) => p.trim()).map((p) => {
+      const parts = p.trim().split(":");
+      return {
+        name: parts[0]?.trim() || "",
+        type: parts[1]?.trim() || "unknown"
+      };
+    });
+    codeUnits.push({
+      type: "witness",
+      name,
+      code: witnessCode,
+      startLine,
+      endLine,
+      isPublic: false,
+      isPrivate: true,
+      parameters,
+      returnType
+    });
+  }
+  const typeRegex = /(export\s+)?type\s+(\w+)\s*=\s*([^;]+);/g;
+  let typeMatch;
+  while ((typeMatch = typeRegex.exec(content)) !== null) {
+    const isExport = !!typeMatch[1];
+    const name = typeMatch[2];
+    const startLine = content.substring(0, typeMatch.index).split("\n").length;
+    if (isExport) {
+      exports.push(name);
+    }
+    codeUnits.push({
+      type: "type",
+      name,
+      code: typeMatch[0],
+      startLine,
+      endLine: startLine,
+      isPublic: isExport,
+      isPrivate: false,
+      returnType: typeMatch[3].trim()
+    });
+  }
+  return {
+    path,
+    language: "compact",
+    content,
+    codeUnits,
+    imports,
+    exports,
+    metadata: {
+      hasLedger,
+      hasCircuits,
+      hasWitnesses,
+      lineCount: lines.length
+    }
+  };
+}
+
+// src/pipeline/embeddings.ts
+import OpenAI from "openai";
+var EmbeddingGenerator = class {
+  openai = null;
+  model;
+  constructor() {
+    this.model = config.embeddingModel;
+    if (config.openaiApiKey) {
+      this.openai = new OpenAI({
+        apiKey: config.openaiApiKey
+      });
+    }
+  }
+  /**
+   * Generate embeddings for a single text
+   */
+  async generateEmbedding(text) {
+    if (!this.openai) {
+      logger.warn("No OpenAI API key configured, using dummy embeddings");
+      return {
+        text,
+        embedding: new Array(1536).fill(0).map(() => Math.random() - 0.5),
+        model: "dummy"
+      };
+    }
+    try {
+      const response = await this.openai.embeddings.create({
+        model: this.model,
+        input: text
+      });
+      return {
+        text,
+        embedding: response.data[0].embedding,
+        model: this.model,
+        tokenCount: response.usage?.total_tokens
+      };
+    } catch (error) {
+      logger.error("Failed to generate embedding", { error: String(error) });
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings for multiple texts in batch
+   */
+  async generateEmbeddings(texts) {
+    if (!this.openai) {
+      logger.warn("No OpenAI API key configured, using dummy embeddings");
+      return texts.map((text) => ({
+        text,
+        embedding: new Array(1536).fill(0).map(() => Math.random() - 0.5),
+        model: "dummy"
+      }));
+    }
+    try {
+      const batchSize = 100;
+      const results = [];
+      for (let i = 0; i < texts.length; i += batchSize) {
+        const batch = texts.slice(i, i + batchSize);
+        logger.debug(`Generating embeddings for batch ${i / batchSize + 1}`);
+        const response = await this.openai.embeddings.create({
+          model: this.model,
+          input: batch
+        });
+        for (let j = 0; j < batch.length; j++) {
+          results.push({
+            text: batch[j],
+            embedding: response.data[j].embedding,
+            model: this.model
+          });
+        }
+      }
+      return results;
+    } catch (error) {
+      logger.error("Failed to generate batch embeddings", {
+        error: String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Calculate cosine similarity between two embeddings
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Embeddings must have the same length");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+};
+var embeddingGenerator = new EmbeddingGenerator();
+
+// src/pipeline/releases.ts
+import { Octokit as Octokit2 } from "octokit";
+var ReleaseTracker = class {
+  octokit;
+  cache = /* @__PURE__ */ new Map();
+  cacheMaxAge = 1e3 * 60 * 15;
+  // 15 minutes
+  constructor(token) {
+    this.octokit = new Octokit2({
+      auth: token || config.githubToken
+    });
+  }
+  /**
+   * Get all releases for a repository
+   */
+  async getReleases(owner, repo, limit = 20) {
+    try {
+      const { data } = await this.octokit.rest.repos.listReleases({
+        owner,
+        repo,
+        per_page: limit
+      });
+      return data.map((release) => ({
+        tag: release.tag_name,
+        name: release.name || release.tag_name,
+        body: release.body || "",
+        publishedAt: release.published_at || release.created_at,
+        url: release.html_url,
+        isPrerelease: release.prerelease,
+        assets: release.assets.map((asset) => ({
+          name: asset.name,
+          downloadUrl: asset.browser_download_url
+        }))
+      }));
+    } catch (error) {
+      logger.warn(`Failed to fetch releases for ${owner}/${repo}`, {
+        error: String(error)
+      });
+      return [];
+    }
+  }
+  /**
+   * Parse a release body to extract structured changelog info
+   */
+  parseChangelog(releaseBody, version, date) {
+    const changes = {
+      breaking: [],
+      features: [],
+      fixes: [],
+      deprecations: []
+    };
+    const lines = releaseBody.split("\n");
+    let currentSection = null;
+    for (const line of lines) {
+      const trimmed = line.trim().toLowerCase();
+      if (trimmed.includes("breaking") || trimmed.includes("\u26A0\uFE0F")) {
+        currentSection = "breaking";
+        continue;
+      }
+      if (trimmed.includes("feature") || trimmed.includes("added") || trimmed.includes("\u2728") || trimmed.includes("\u{1F680}")) {
+        currentSection = "features";
+        continue;
+      }
+      if (trimmed.includes("fix") || trimmed.includes("bug") || trimmed.includes("\u{1F41B}") || trimmed.includes("\u{1F527}")) {
+        currentSection = "fixes";
+        continue;
+      }
+      if (trimmed.includes("deprecat") || trimmed.includes("\u26A0")) {
+        currentSection = "deprecations";
+        continue;
+      }
+      if (currentSection && (line.startsWith("-") || line.startsWith("*") || line.match(/^\d+\./))) {
+        const content = line.replace(/^[-*]\s*|\d+\.\s*/, "").trim();
+        if (content) {
+          changes[currentSection].push(content);
+        }
+      }
+    }
+    return {
+      version,
+      date,
+      changes,
+      rawBody: releaseBody
+    };
+  }
+  /**
+   * Get version info for a repository with caching
+   */
+  async getVersionInfo(owner, repo) {
+    const repoKey = `${owner}/${repo}`;
+    const cached = this.cache.get(repoKey);
+    if (cached) {
+      const age = Date.now() - new Date(cached.lastChecked).getTime();
+      if (age < this.cacheMaxAge) {
+        return cached;
+      }
+    }
+    const releases = await this.getReleases(owner, repo);
+    const latestRelease = releases[0] || null;
+    const latestStableRelease = releases.find((r) => !r.isPrerelease) || null;
+    const changelog = releases.map(
+      (r) => this.parseChangelog(r.body, r.tag, r.publishedAt)
+    );
+    const info = {
+      repository: repoKey,
+      latestRelease,
+      latestStableRelease,
+      recentReleases: releases.slice(0, 10),
+      changelog,
+      lastChecked: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(repoKey, info);
+    return info;
+  }
+  /**
+   * Get breaking changes since a specific version
+   */
+  async getBreakingChangesSince(owner, repo, sinceVersion) {
+    const info = await this.getVersionInfo(owner, repo);
+    const breakingChanges = [];
+    for (const entry of info.changelog) {
+      if (entry.version === sinceVersion) break;
+      breakingChanges.push(...entry.changes.breaking);
+    }
+    return breakingChanges;
+  }
+  /**
+   * Check if a version is outdated
+   */
+  async isOutdated(owner, repo, currentVersion) {
+    const info = await this.getVersionInfo(owner, repo);
+    const latestVersion = info.latestStableRelease?.tag || info.latestRelease?.tag || null;
+    if (!latestVersion) {
+      return {
+        isOutdated: false,
+        latestVersion: null,
+        versionsBehind: 0,
+        hasBreakingChanges: false
+      };
+    }
+    const releaseIndex = info.recentReleases.findIndex(
+      (r) => r.tag === currentVersion
+    );
+    const versionsBehind = releaseIndex === -1 ? info.recentReleases.length : releaseIndex;
+    const breakingChanges = await this.getBreakingChangesSince(
+      owner,
+      repo,
+      currentVersion
+    );
+    return {
+      isOutdated: currentVersion !== latestVersion,
+      latestVersion,
+      versionsBehind,
+      hasBreakingChanges: breakingChanges.length > 0
+    };
+  }
+  /**
+   * Get migration guide between two versions
+   */
+  async getMigrationGuide(owner, repo, fromVersion, toVersion) {
+    const info = await this.getVersionInfo(owner, repo);
+    const to = toVersion || info.latestStableRelease?.tag || info.latestRelease?.tag || fromVersion;
+    const result = {
+      from: fromVersion,
+      to,
+      breakingChanges: [],
+      deprecations: [],
+      newFeatures: [],
+      migrationSteps: []
+    };
+    let inRange = false;
+    for (const entry of [...info.changelog].reverse()) {
+      if (entry.version === fromVersion) {
+        inRange = true;
+        continue;
+      }
+      if (entry.version === to) {
+        result.breakingChanges.push(...entry.changes.breaking);
+        result.deprecations.push(...entry.changes.deprecations);
+        result.newFeatures.push(...entry.changes.features);
+        break;
+      }
+      if (inRange) {
+        result.breakingChanges.push(...entry.changes.breaking);
+        result.deprecations.push(...entry.changes.deprecations);
+        result.newFeatures.push(...entry.changes.features);
+      }
+    }
+    result.migrationSteps = result.breakingChanges.map(
+      (change) => `Review and update: ${change}`
+    );
+    return result;
+  }
+  /**
+   * Get version-specific documentation hints
+   */
+  getVersionContext(versionInfo) {
+    const parts = [];
+    if (versionInfo.latestRelease) {
+      parts.push(
+        `Latest version: ${versionInfo.latestRelease.tag} (${versionInfo.latestRelease.publishedAt.split("T")[0]})`
+      );
+    }
+    if (versionInfo.latestStableRelease && versionInfo.latestStableRelease !== versionInfo.latestRelease) {
+      parts.push(`Latest stable: ${versionInfo.latestStableRelease.tag}`);
+    }
+    const recentBreaking = versionInfo.changelog.slice(0, 3).flatMap((c) => c.changes.breaking);
+    if (recentBreaking.length > 0) {
+      parts.push(
+        `Recent breaking changes:
+${recentBreaking.map((b) => `  - ${b}`).join("\n")}`
+      );
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Fetch a file at a specific version/tag
+   * This is critical for ensuring code recommendations match the user's version
+   */
+  async getFileAtVersion(owner, repo, filePath, version) {
+    try {
+      const { data } = await this.octokit.rest.repos.getContent({
+        owner,
+        repo,
+        path: filePath,
+        ref: version
+        // Can be a tag like "v1.0.0" or branch
+      });
+      if (Array.isArray(data) || data.type !== "file") {
+        return null;
+      }
+      const content = data.encoding === "base64" ? Buffer.from(data.content, "base64").toString("utf-8") : data.content;
+      return { content, version };
+    } catch (error) {
+      logger.warn(
+        `Failed to fetch ${filePath} at ${version} from ${owner}/${repo}`,
+        {
+          error: String(error)
+        }
+      );
+      return null;
+    }
+  }
+  /**
+   * Compare syntax between two versions of a file
+   * Useful for showing what changed in API/syntax
+   */
+  async compareSyntax(owner, repo, filePath, oldVersion, newVersion) {
+    const [oldFile, newFile] = await Promise.all([
+      this.getFileAtVersion(owner, repo, filePath, oldVersion),
+      this.getFileAtVersion(owner, repo, filePath, newVersion)
+    ]);
+    return {
+      oldVersion,
+      newVersion,
+      oldContent: oldFile?.content || null,
+      newContent: newFile?.content || null,
+      hasDifferences: oldFile?.content !== newFile?.content
+    };
+  }
+  /**
+   * Get the grammar/syntax reference files at the latest version
+   * These are the source of truth for valid Compact syntax
+   */
+  async getLatestSyntaxReference(owner, repo) {
+    const versionInfo = await this.getVersionInfo(owner, repo);
+    const version = versionInfo.latestStableRelease?.tag || versionInfo.latestRelease?.tag || "main";
+    const syntaxFilePaths = [
+      "docs/grammar.md",
+      "docs/syntax.md",
+      "docs/reference.md",
+      "src/grammar.ts",
+      "grammar/compact.grammar",
+      "README.md"
+    ];
+    const syntaxFiles = [];
+    for (const path of syntaxFilePaths) {
+      const file = await this.getFileAtVersion(owner, repo, path, version);
+      if (file) {
+        syntaxFiles.push({ path, content: file.content });
+      }
+    }
+    if (syntaxFiles.length === 0) {
+      return null;
+    }
+    return { version, syntaxFiles };
+  }
+};
+var releaseTracker = new ReleaseTracker();
+
+// src/utils/health.ts
+var startTime = Date.now();
+var VERSION = process.env.npm_package_version || "0.0.3";
+async function checkGitHubAPI() {
+  const start = Date.now();
+  try {
+    const rateLimit = await githubClient.getRateLimit();
+    const latency = Date.now() - start;
+    if (rateLimit.remaining < 100) {
+      return {
+        status: "warn",
+        message: `Rate limit low: ${rateLimit.remaining}/${rateLimit.limit} remaining`,
+        latency
+      };
+    }
+    return {
+      status: "pass",
+      message: `Rate limit: ${rateLimit.remaining}/${rateLimit.limit}`,
+      latency
+    };
+  } catch (error) {
+    return {
+      status: "fail",
+      message: `GitHub API error: ${error instanceof Error ? error.message : String(error)}`,
+      latency: Date.now() - start
+    };
+  }
+}
+async function checkVectorStore() {
+  try {
+    const { vectorStore: vectorStore2 } = await import("./db-YDGUWI5K.js");
+    if (vectorStore2) {
+      return {
+        status: "pass",
+        message: "Vector store available"
+      };
+    }
+    return {
+      status: "warn",
+      message: "Vector store not initialized (semantic search unavailable)"
+    };
+  } catch {
+    return {
+      status: "warn",
+      message: "Vector store not configured (semantic search unavailable)"
+    };
+  }
+}
+function checkMemory() {
+  const usage = process.memoryUsage();
+  const heapUsedMB = Math.round(usage.heapUsed / 1024 / 1024);
+  const heapTotalMB = Math.round(usage.heapTotal / 1024 / 1024);
+  const percentUsed = Math.round(usage.heapUsed / usage.heapTotal * 100);
+  if (percentUsed > 90) {
+    return {
+      status: "fail",
+      message: `High memory usage: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`
+    };
+  }
+  if (percentUsed > 75) {
+    return {
+      status: "warn",
+      message: `Elevated memory usage: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`
+    };
+  }
+  return {
+    status: "pass",
+    message: `Memory: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`
+  };
+}
+async function getHealthStatus() {
+  const checks = [];
+  const [githubCheck, vectorCheck] = await Promise.all([
+    checkGitHubAPI(),
+    checkVectorStore()
+  ]);
+  const memoryCheck = checkMemory();
+  checks.push(
+    { name: "github_api", ...githubCheck },
+    { name: "vector_store", ...vectorCheck },
+    { name: "memory", ...memoryCheck }
+  );
+  const hasFailure = checks.some((c) => c.status === "fail");
+  const hasWarning = checks.some((c) => c.status === "warn");
+  let status = "healthy";
+  if (hasFailure) {
+    status = "unhealthy";
+  } else if (hasWarning) {
+    status = "degraded";
+  }
+  return {
+    status,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    version: VERSION,
+    uptime: Math.round((Date.now() - startTime) / 1e3),
+    checks
+  };
+}
+function getQuickHealthStatus() {
+  return {
+    status: "healthy",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    version: VERSION,
+    uptime: Math.round((Date.now() - startTime) / 1e3),
+    checks: [{ name: "server", status: "pass" }]
+  };
+}
+
+// src/utils/rate-limit.ts
+var WARNING_THRESHOLD = 0.8;
+var CRITICAL_THRESHOLD = 0.95;
+var cachedRateLimit = null;
+var lastUpdate = 0;
+var CACHE_TTL = 60 * 1e3;
+function updateRateLimit(info) {
+  cachedRateLimit = info;
+  lastUpdate = Date.now();
+}
+function getRateLimitStatus() {
+  if (!cachedRateLimit) {
+    return {
+      isLimited: false,
+      isWarning: false,
+      remaining: 5e3,
+      limit: 5e3,
+      resetAt: /* @__PURE__ */ new Date(),
+      percentUsed: 0,
+      message: "Rate limit info not yet available"
+    };
+  }
+  const percentUsed = cachedRateLimit.used / cachedRateLimit.limit;
+  const isWarning = percentUsed >= WARNING_THRESHOLD;
+  const isLimited = percentUsed >= CRITICAL_THRESHOLD || cachedRateLimit.remaining <= 10;
+  let message;
+  if (isLimited) {
+    const minutesUntilReset = Math.ceil(
+      (cachedRateLimit.reset.getTime() - Date.now()) / 6e4
+    );
+    message = `Rate limited! Resets in ${minutesUntilReset} minutes`;
+  } else if (isWarning) {
+    message = `Warning: ${cachedRateLimit.remaining} API calls remaining (${Math.round(percentUsed * 100)}% used)`;
+  } else {
+    message = `${cachedRateLimit.remaining}/${cachedRateLimit.limit} API calls remaining`;
+  }
+  return {
+    isLimited,
+    isWarning,
+    remaining: cachedRateLimit.remaining,
+    limit: cachedRateLimit.limit,
+    resetAt: cachedRateLimit.reset,
+    percentUsed: Math.round(percentUsed * 100),
+    message
+  };
+}
+function shouldProceedWithRequest() {
+  if (!cachedRateLimit) {
+    return { proceed: true };
+  }
+  if (cachedRateLimit.remaining <= 10) {
+    const waitMs = Math.max(0, cachedRateLimit.reset.getTime() - Date.now());
+    return {
+      proceed: false,
+      reason: `Rate limit nearly exhausted (${cachedRateLimit.remaining} remaining)`,
+      waitMs
+    };
+  }
+  return { proceed: true };
+}
+function formatRateLimitStatus() {
+  const status = getRateLimitStatus();
+  if (status.isLimited) {
+    return `\u26D4 ${status.message}`;
+  } else if (status.isWarning) {
+    return `\u26A0\uFE0F ${status.message}`;
+  } else {
+    return `\u2705 ${status.message}`;
+  }
+}
+
+// src/utils/cache.ts
+var Cache = class {
+  cache = /* @__PURE__ */ new Map();
+  options;
+  stats = { hits: 0, misses: 0 };
+  constructor(options) {
+    this.options = {
+      ttl: options.ttl,
+      maxSize: options.maxSize || 1e3,
+      name: options.name || "cache"
+    };
+  }
+  /**
+   * Get a value from the cache
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return void 0;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.stats.misses++;
+      return void 0;
+    }
+    this.stats.hits++;
+    return entry.value;
+  }
+  /**
+   * Set a value in the cache
+   */
+  set(key, value, ttl) {
+    if (this.cache.size >= this.options.maxSize) {
+      this.evictOldest();
+    }
+    const now = Date.now();
+    this.cache.set(key, {
+      value,
+      expiresAt: now + (ttl || this.options.ttl),
+      createdAt: now
+    });
+  }
+  /**
+   * Check if a key exists and is not expired
+   */
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete a key from the cache
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  clear() {
+    this.cache.clear();
+    logger.debug(`Cache cleared: ${this.options.name}`);
+  }
+  /**
+   * Remove expired entries
+   */
+  prune() {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+        pruned++;
+      }
+    }
+    if (pruned > 0) {
+      logger.debug(`Cache pruned: ${this.options.name}`, { pruned });
+    }
+    return pruned;
+  }
+  /**
+   * Evict the oldest entry to make room
+   */
+  evictOldest() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.createdAt < oldestTime) {
+        oldestTime = entry.createdAt;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    return {
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      size: this.cache.size,
+      hitRate: total > 0 ? this.stats.hits / total : 0
+    };
+  }
+  /**
+   * Get or set with a factory function
+   */
+  async getOrSet(key, factory, ttl) {
+    const cached = this.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const value = await factory();
+    this.set(key, value, ttl);
+    return value;
+  }
+};
+function createCacheKey(...parts) {
+  return parts.filter((p) => p !== void 0).map((p) => String(p)).join(":");
+}
+var searchCache = new Cache({
+  ttl: 5 * 60 * 1e3,
+  // 5 minutes
+  maxSize: 500,
+  name: "search"
+});
+var fileCache = new Cache({
+  ttl: 10 * 60 * 1e3,
+  // 10 minutes
+  maxSize: 200,
+  name: "file"
+});
+var metadataCache = new Cache({
+  ttl: 15 * 60 * 1e3,
+  // 15 minutes
+  maxSize: 100,
+  name: "metadata"
+});
+function pruneAllCaches() {
+  searchCache.prune();
+  fileCache.prune();
+  metadataCache.prune();
+}
+setInterval(pruneAllCaches, 5 * 60 * 1e3);
+
+// src/utils/hosted-api.ts
+var API_TIMEOUT = 1e4;
+async function apiRequest(endpoint, options = {}) {
+  const url = `${config.hostedApiUrl}${endpoint}`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), API_TIMEOUT);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "midnight-mcp",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(errorData.error || `API error: ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(
+        "API request timed out. The hosted service may be unavailable."
+      );
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function searchCompactHosted(query, limit = 10) {
+  logger.debug("Searching Compact code via hosted API", { query });
+  return apiRequest("/v1/search/compact", {
+    method: "POST",
+    body: JSON.stringify({ query, limit })
+  });
+}
+async function searchTypeScriptHosted(query, limit = 10, includeTypes = true) {
+  logger.debug("Searching TypeScript code via hosted API", { query });
+  return apiRequest("/v1/search/typescript", {
+    method: "POST",
+    body: JSON.stringify({ query, limit, includeTypes })
+  });
+}
+async function searchDocsHosted(query, limit = 10, category = "all") {
+  logger.debug("Searching documentation via hosted API", { query });
+  return apiRequest("/v1/search/docs", {
+    method: "POST",
+    body: JSON.stringify({ query, limit, category })
+  });
+}
+function trackToolCall(tool, success, durationMs, version) {
+  apiRequest("/v1/track/tool", {
+    method: "POST",
+    body: JSON.stringify({ tool, success, durationMs, version })
+  }).catch(() => {
+  });
+}
+
+// src/utils/serializer.ts
+import yaml from "js-yaml";
+var useJsonOutput = false;
+function setOutputFormat(json) {
+  useJsonOutput = json;
+}
+function serialize(data) {
+  if (useJsonOutput) {
+    return JSON.stringify(data, null, 2);
+  }
+  try {
+    return yaml.dump(data, {
+      indent: 2,
+      lineWidth: 120,
+      noRefs: true,
+      // Avoid YAML anchors/aliases for cleaner output
+      quotingType: '"',
+      forceQuotes: false,
+      sortKeys: false
+      // Preserve object key order
+    });
+  } catch {
+    return JSON.stringify(data, null, 2);
+  }
+}
+
+// src/utils/version.ts
+var CURRENT_VERSION = "0.2.2";
+
+// src/db/vectorStore.ts
+var VectorStore = class {
+  client = null;
+  collection = null;
+  collectionName = "midnight-code";
+  initialized = false;
+  /**
+   * Initialize the vector store connection
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      this.client = new ChromaClient({
+        path: config.chromaUrl
+      });
+      this.collection = await this.client.getOrCreateCollection({
+        name: this.collectionName,
+        metadata: {
+          description: "Midnight blockchain code and documentation"
+        }
+      });
+      this.initialized = true;
+      logger.info("Vector store initialized successfully");
+    } catch (error) {
+      logger.error("Failed to initialize vector store", {
+        error: String(error)
+      });
+      logger.warn("Vector store unavailable, using in-memory fallback");
+    }
+  }
+  /**
+   * Add documents to the vector store
+   */
+  async addDocuments(documents) {
+    if (!this.collection) {
+      logger.warn("Vector store not initialized, skipping document storage");
+      return;
+    }
+    try {
+      const ids = documents.map((d) => d.id);
+      const embeddings = documents.map((d) => d.embedding);
+      const metadatas = documents.map((d) => ({
+        repository: d.metadata.repository,
+        filePath: d.metadata.filePath,
+        language: d.metadata.language,
+        startLine: d.metadata.startLine,
+        endLine: d.metadata.endLine,
+        codeType: d.metadata.codeType,
+        codeName: d.metadata.codeName,
+        isPublic: d.metadata.isPublic
+      }));
+      const documentContents = documents.map((d) => d.content);
+      await this.collection.add({
+        ids,
+        embeddings,
+        metadatas,
+        documents: documentContents
+      });
+      logger.debug(`Added ${documents.length} documents to vector store`);
+    } catch (error) {
+      logger.error("Failed to add documents to vector store", {
+        error: String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Search for similar documents
+   */
+  async search(query, limit = 10, filter) {
+    if (!this.collection) {
+      logger.warn("Vector store not initialized, returning empty results");
+      return [];
+    }
+    try {
+      const queryEmbedding = await embeddingGenerator.generateEmbedding(query);
+      const whereFilter = {};
+      if (filter?.repository) {
+        whereFilter.repository = filter.repository;
+      }
+      if (filter?.language) {
+        whereFilter.language = filter.language;
+      }
+      if (filter?.codeType) {
+        whereFilter.codeType = filter.codeType;
+      }
+      if (filter?.isPublic !== void 0) {
+        whereFilter.isPublic = filter.isPublic;
+      }
+      const results = await this.collection.query({
+        queryEmbeddings: [queryEmbedding.embedding],
+        nResults: limit,
+        where: Object.keys(whereFilter).length > 0 ? whereFilter : void 0
+      });
+      const searchResults = [];
+      if (results.ids[0] && results.documents[0] && results.metadatas[0]) {
+        for (let i = 0; i < results.ids[0].length; i++) {
+          const metadata = results.metadatas[0][i];
+          searchResults.push({
+            id: results.ids[0][i],
+            content: results.documents[0][i] || "",
+            score: results.distances ? 1 - (results.distances[0][i] || 0) : 0,
+            metadata
+          });
+        }
+      }
+      return searchResults;
+    } catch (error) {
+      logger.error("Search failed", { error: String(error) });
+      return [];
+    }
+  }
+  /**
+   * Delete documents by file path
+   */
+  async deleteByPath(repository, filePath) {
+    if (!this.collection) return;
+    try {
+      await this.collection.delete({
+        where: {
+          repository,
+          filePath
+        }
+      });
+      logger.debug(`Deleted documents for ${repository}:${filePath}`);
+    } catch (error) {
+      logger.error("Failed to delete documents", { error: String(error) });
+    }
+  }
+  /**
+   * Delete all documents for a repository
+   */
+  async deleteRepository(repository) {
+    if (!this.collection) return;
+    try {
+      await this.collection.delete({
+        where: { repository }
+      });
+      logger.info(`Deleted all documents for repository ${repository}`);
+    } catch (error) {
+      logger.error("Failed to delete repository documents", {
+        error: String(error)
+      });
+    }
+  }
+  /**
+   * Get collection statistics
+   */
+  async getStats() {
+    if (!this.collection) {
+      return { count: 0 };
+    }
+    try {
+      const count = await this.collection.count();
+      return { count };
+    } catch (error) {
+      logger.error("Failed to get stats", { error: String(error) });
+      return { count: 0 };
+    }
+  }
+  /**
+   * Clear all data from the collection
+   */
+  async clear() {
+    if (!this.client) return;
+    try {
+      await this.client.deleteCollection({ name: this.collectionName });
+      this.collection = await this.client.getOrCreateCollection({
+        name: this.collectionName
+      });
+      logger.info("Vector store cleared");
+    } catch (error) {
+      logger.error("Failed to clear vector store", { error: String(error) });
+    }
+  }
+};
+var vectorStore = new VectorStore();
+
+export {
+  isHostedMode,
+  DEFAULT_REPOSITORIES,
+  setMCPLogCallback,
+  logger,
+  SelfCorrectionHints,
+  formatErrorResponse,
+  validateQuery,
+  validateNumber,
+  githubClient,
+  parseCompactFile,
+  vectorStore,
+  releaseTracker,
+  getHealthStatus,
+  getQuickHealthStatus,
+  getRateLimitStatus,
+  formatRateLimitStatus,
+  createCacheKey,
+  searchCache,
+  fileCache,
+  metadataCache,
+  searchCompactHosted,
+  searchTypeScriptHosted,
+  searchDocsHosted,
+  trackToolCall,
+  setOutputFormat,
+  serialize,
+  CURRENT_VERSION
+};
+//# sourceMappingURL=chunk-HOWO4K5A.js.map