memory-journal-mcp 6.2.1 → 7.0.0

package/dist/chunk-ARLH46WS.js

@@ -0,0 +1,1659 @@
+import { Octokit } from '@octokit/rest';
+import { graphql } from '@octokit/graphql';
+import * as simpleGitImport from 'simple-git';
+import { execFileSync } from 'child_process';
+
+// src/github/github-integration/client.ts
+
+// src/utils/errors/suggestions.ts
+var GENERIC_CODES = /* @__PURE__ */ new Set(["QUERY_FAILED", "INTERNAL_ERROR", "UNKNOWN_ERROR"]);
+var ERROR_SUGGESTIONS = [
+  // Resource not found patterns
+  {
+    pattern: /not found/i,
+    suggestion: "Verify the resource identifier and try again",
+    code: "RESOURCE_NOT_FOUND"
+  },
+  {
+    pattern: /no such table/i,
+    suggestion: "The database table does not exist. Run database initialization.",
+    code: "TABLE_NOT_FOUND"
+  },
+  // Permission / access patterns
+  {
+    pattern: /permission denied|SQLITE_READONLY/i,
+    suggestion: "Check file permissions and database access rights",
+    code: "PERMISSION_DENIED"
+  },
+  // Connection / lock patterns
+  {
+    pattern: /database is locked/i,
+    suggestion: "The database is locked by another process. Retry after a short delay.",
+    code: "CONNECTION_FAILED"
+  },
+  // Constraint patterns
+  {
+    pattern: /SQLITE_CONSTRAINT|unique constraint/i,
+    suggestion: "A uniqueness or integrity constraint was violated. Check input values.",
+    code: "VALIDATION_FAILED"
+  },
+  // Disk / space patterns
+  {
+    pattern: /disk I\/O|SQLITE_FULL/i,
+    suggestion: "The disk may be full or the filesystem is read-only."
+  },
+  // Malformed input patterns
+  {
+    pattern: /malformed|invalid json|unexpected token/i,
+    suggestion: "The input appears malformed. Check the format and try again.",
+    code: "VALIDATION_FAILED"
+  },
+  // Schema / types patterns
+  {
+    pattern: /invalid input syntax for type|requires a.*column/i,
+    suggestion: "The provided value is not valid for the assigned type.",
+    code: "VALIDATION_FAILED"
+  },
+  {
+    pattern: /^Missing required parameters:/i,
+    suggestion: "Provide all required parameters in your request.",
+    code: "VALIDATION_FAILED"
+  },
+  // Codemode / Sandbox patterns
+  {
+    pattern: /execution timed out/i,
+    suggestion: "Reduce code complexity or increase timeout (max 30s). Break into smaller operations.",
+    code: "QUERY_FAILED"
+  },
+  {
+    pattern: /code validation failed/i,
+    suggestion: "Check for blocked patterns. Use mj.* API instead.",
+    code: "VALIDATION_FAILED"
+  },
+  {
+    pattern: /sandbox.*not initialized/i,
+    suggestion: "Internal sandbox error. Retry the operation.",
+    code: "INTERNAL_ERROR"
+  }
+];
+function matchSuggestion(message) {
+  for (const entry of ERROR_SUGGESTIONS) {
+    if (entry.pattern.test(message)) {
+      return { suggestion: entry.suggestion, code: entry.code };
+    }
+  }
+  return void 0;
+}
+
+// src/types/errors.ts
+var MemoryJournalMcpError = class extends Error {
+  /** Module-prefixed error code */
+  code;
+  /** Error category for programmatic handling */
+  category;
+  /** Actionable suggestion for resolving the error */
+  suggestion;
+  /** Whether the operation can be retried */
+  recoverable;
+  /** Additional structured context */
+  details;
+  constructor(message, code, category, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = "MemoryJournalMcpError";
+    this.category = category;
+    this.recoverable = options?.recoverable ?? false;
+    this.details = options?.details;
+    const matched = matchSuggestion(message);
+    if (GENERIC_CODES.has(code) && matched?.code) {
+      this.code = matched.code;
+    } else {
+      this.code = code;
+    }
+    this.suggestion = options?.suggestion ?? matched?.suggestion;
+  }
+  /**
+   * Convert to a structured ErrorResponse for tool responses.
+   */
+  toResponse() {
+    return {
+      success: false,
+      error: this.message,
+      code: this.code,
+      category: this.category,
+      suggestion: this.suggestion,
+      recoverable: this.recoverable,
+      ...this.details ? { details: this.details } : {}
+    };
+  }
+};
+var ConnectionError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "CONNECTION_FAILED", "connection" /* CONNECTION */, {
+      suggestion: "Check database path and file permissions",
+      recoverable: true,
+      details
+    });
+    this.name = "ConnectionError";
+  }
+};
+var QueryError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "QUERY_FAILED", "query" /* QUERY */, {
+      suggestion: "Check query parameters and database state",
+      recoverable: false,
+      details
+    });
+    this.name = "QueryError";
+  }
+};
+var ValidationError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "VALIDATION_FAILED", "validation" /* VALIDATION */, {
+      suggestion: "Check input parameters against the tool schema",
+      recoverable: false,
+      details
+    });
+    this.name = "ValidationError";
+  }
+};
+var ResourceNotFoundError = class extends MemoryJournalMcpError {
+  constructor(resourceType, identifier) {
+    super(
+      `${resourceType} not found: ${identifier}`,
+      "RESOURCE_NOT_FOUND",
+      "resource" /* RESOURCE */,
+      {
+        suggestion: `Verify the ${resourceType.toLowerCase()} identifier and try again`,
+        recoverable: false,
+        details: { resourceType, identifier }
+      }
+    );
+    this.name = "ResourceNotFoundError";
+  }
+};
+var ConfigurationError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", "configuration" /* CONFIGURATION */, {
+      suggestion: "Check server configuration and environment variables",
+      recoverable: false,
+      details
+    });
+    this.name = "ConfigurationError";
+  }
+};
+
+// src/utils/security-utils.ts
+var GIT_COMMAND_TIMEOUT_MS = 3e3;
+var SecurityError = class extends MemoryJournalMcpError {
+  constructor(message, code) {
+    super(message, code, "validation" /* VALIDATION */, {
+      suggestion: "Check input for security violations",
+      recoverable: false
+    });
+    this.name = "SecurityError";
+  }
+};
+var InvalidDateFormatError = class extends SecurityError {
+  constructor(value) {
+    super(`Invalid date format pattern: '${value}'`, "INVALID_DATE_FORMAT");
+    this.name = "InvalidDateFormatError";
+  }
+};
+var PathTraversalError = class extends SecurityError {
+  constructor(path) {
+    super(`Path traversal detected: '${path}'`, "PATH_TRAVERSAL");
+    this.name = "PathTraversalError";
+  }
+};
+var ALLOWED_DATE_FORMATS = {
+  day: "%Y-%m-%d",
+  week: "%Y-W%W",
+  month: "%Y-%m"
+};
+function validateDateFormatPattern(groupBy) {
+  const format = ALLOWED_DATE_FORMATS[groupBy];
+  if (!format) {
+    throw new InvalidDateFormatError(groupBy);
+  }
+  return format;
+}
+function assertNoPathTraversal(filename) {
+  if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
+    throw new PathTraversalError(filename);
+  }
+}
+var TOKEN_PATTERNS = [
+  // GitHub personal access tokens (classic and fine-grained)
+  /ghp_[A-Za-z0-9_]{36,}/g,
+  /github_pat_[A-Za-z0-9_]{82,}/g,
+  // Authorization headers in error dumps
+  /Authorization:\s*(?:token|Bearer)\s+\S+/gi,
+  // Generic Bearer tokens
+  /Bearer\s+[A-Za-z0-9._\-~+/]+=*/gi
+];
+function sanitizeErrorForLogging(message) {
+  let sanitized = message;
+  for (const pattern of TOKEN_PATTERNS) {
+    pattern.lastIndex = 0;
+    sanitized = sanitized.replace(pattern, "[REDACTED]");
+  }
+  return sanitized;
+}
+function sanitizeAuthor(raw) {
+  return raw.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 100);
+}
+function resolveAuthor() {
+  const envAuthor = process.env["TEAM_AUTHOR"]?.trim().replace(/"/g, "");
+  if (envAuthor) return sanitizeAuthor(envAuthor);
+  try {
+    const gitUser = execFileSync("git", ["config", "user.name"], {
+      encoding: "utf-8",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }).trim().replace(/"/g, "");
+    if (gitUser) return sanitizeAuthor(gitUser);
+  } catch {
+  }
+  return "unknown";
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 7,
+  info: 6,
+  notice: 5,
+  warning: 4,
+  error: 3,
+  critical: 2
+};
+var Logger = class {
+  minLevel;
+  constructor(level = "info") {
+    this.minLevel = LOG_LEVELS[level];
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] <= this.minLevel;
+  }
+  log(level, message, context) {
+    if (!this.shouldLog(level)) return;
+    const safeMessage = message.replace(/\n|\r/g, "");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const levelUpper = level.toUpperCase().padEnd(8);
+    const mod = context?.module ? `[${context.module.replace(/\n|\r/g, "")}]` : "";
+    const op = context?.operation ? `[${context.operation.replace(/\n|\r/g, "")}]` : "";
+    let line = `[${timestamp}] [${levelUpper}] ${mod}${op} ${safeMessage}`;
+    const extras = { ...context };
+    delete extras["module"];
+    delete extras["operation"];
+    if (extras["error"] != null && typeof extras["error"] === "string") {
+      extras["error"] = sanitizeErrorForLogging(extras["error"]);
+    }
+    if (Object.keys(extras).length > 0) {
+      line += ` ${JSON.stringify(extras).replace(/\n|\r/g, "")}`;
+    }
+    console.error(line);
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  notice(message, context) {
+    this.log("notice", message, context);
+  }
+  warning(message, context) {
+    this.log("warning", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  critical(message, context) {
+    this.log("critical", message, context);
+  }
+  setLevel(level) {
+    if (level in LOG_LEVELS) {
+      this.minLevel = LOG_LEVELS[level];
+    }
+  }
+};
+var rawLevel = process.env["LOG_LEVEL"] ?? "info";
+var envLevel = rawLevel in LOG_LEVELS ? rawLevel : "info";
+var logger = new Logger(envLevel);
+
+// src/github/github-integration/client.ts
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var TRAFFIC_CACHE_TTL_MS = 10 * 60 * 1e3;
+var simpleGit2 = simpleGitImport.simpleGit;
+var GitHubClient = class {
+  octokit = null;
+  graphqlWithAuth = null;
+  git;
+  token;
+  cachedRepoInfo = null;
+  apiCache = /* @__PURE__ */ new Map();
+  constructor(workingDir = ".") {
+    this.token = process.env["GITHUB_TOKEN"];
+    const effectiveDir = workingDir;
+    const resolvedDir = effectiveDir === "." ? process.cwd() : effectiveDir;
+    logger.info("GitHub integration using directory", {
+      module: "GitHub",
+      workingDir,
+      effectiveDir,
+      resolvedDir,
+      cwd: process.cwd()
+    });
+    this.git = simpleGit2(effectiveDir);
+    if (this.token) {
+      this.octokit = new Octokit({ auth: this.token });
+      this.graphqlWithAuth = graphql.defaults({
+        headers: { authorization: `token ${this.token}` }
+      });
+      logger.info("GitHub integration initialized with token", { module: "GitHub" });
+    } else {
+      logger.info("GitHub integration initialized without token (limited functionality)", {
+        module: "GitHub"
+      });
+    }
+  }
+  isApiAvailable() {
+    return this.octokit !== null;
+  }
+  getCached(key) {
+    const entry = this.apiCache.get(key);
+    if (entry && Date.now() - entry.timestamp < CACHE_TTL_MS) {
+      this.apiCache.delete(key);
+      this.apiCache.set(key, entry);
+      return entry.data;
+    }
+    if (entry) {
+      this.apiCache.delete(key);
+    }
+    return void 0;
+  }
+  getCachedWithTtl(key, ttlMs) {
+    const entry = this.apiCache.get(key);
+    if (entry && Date.now() - entry.timestamp < ttlMs) {
+      this.apiCache.delete(key);
+      this.apiCache.set(key, entry);
+      return entry.data;
+    }
+    if (entry) {
+      this.apiCache.delete(key);
+    }
+    return void 0;
+  }
+  setCache(key, data) {
+    this.apiCache.delete(key);
+    this.apiCache.set(key, { data, timestamp: Date.now() });
+    if (this.apiCache.size > 100) {
+      const oldestKey = this.apiCache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.apiCache.delete(oldestKey);
+      }
+    }
+  }
+  invalidateCache(prefix) {
+    for (const key of this.apiCache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.apiCache.delete(key);
+      }
+    }
+  }
+  clearCache() {
+    this.apiCache.clear();
+  }
+};
+
+// src/github/github-integration/issues.ts
+var IssuesManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getIssues(owner, repo, state = "open", limit = 20) {
+    if (!this.client.octokit) {
+      return [];
+    }
+    const cacheKey = `issues:${owner}:${repo}:${state}:${String(limit)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.issues.listForRepo({
+        owner,
+        repo,
+        state,
+        per_page: Math.min(limit * 2, 100),
+        sort: "updated",
+        direction: "desc"
+      });
+      const result = response.data.filter((issue) => !issue.pull_request).slice(0, limit).map((issue) => ({
+        number: issue.number,
+        title: issue.title,
+        url: issue.html_url,
+        state: issue.state === "open" ? "OPEN" : "CLOSED",
+        milestone: issue.milestone ? {
+          number: issue.milestone.number,
+          title: issue.milestone.title
+        } : null
+      }));
+      this.client.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error("Failed to get issues", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async getIssue(owner, repo, issueNumber) {
+    if (!this.client.octokit) {
+      return null;
+    }
+    const cacheKey = `issue:${owner}:${repo}:${String(issueNumber)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached !== void 0) return cached;
+    try {
+      const response = await this.client.octokit.issues.get({
+        owner,
+        repo,
+        issue_number: issueNumber
+      });
+      const issue = response.data;
+      if (issue.pull_request) {
+        return null;
+      }
+      const details = {
+        number: issue.number,
+        title: issue.title,
+        url: issue.html_url,
+        state: issue.state === "open" ? "OPEN" : "CLOSED",
+        nodeId: issue.node_id,
+        body: issue.body ?? null,
+        labels: issue.labels.map((l) => typeof l === "string" ? l : l.name ?? ""),
+        assignees: issue.assignees?.map((a) => a.login) ?? [],
+        createdAt: issue.created_at,
+        updatedAt: issue.updated_at,
+        closedAt: issue.closed_at,
+        commentsCount: issue.comments,
+        milestone: issue.milestone ? { number: issue.milestone.number, title: issue.milestone.title } : null
+      };
+      this.client.setCache(cacheKey, details);
+      return details;
+    } catch (error) {
+      logger.error("Failed to get issue details", {
+        module: "GitHub",
+        entityId: issueNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  async createIssue(owner, repo, title, body, labels, assignees, milestone) {
+    if (!this.client.octokit) {
+      logger.error("Cannot create issue: GitHub API not available", { module: "GitHub" });
+      return null;
+    }
+    try {
+      const response = await this.client.octokit.issues.create({
+        owner,
+        repo,
+        title,
+        body,
+        labels,
+        assignees,
+        milestone
+      });
+      logger.info("Created GitHub issue", {
+        module: "GitHub",
+        entityId: response.data.number,
+        context: { title, owner, repo }
+      });
+      return {
+        number: response.data.number,
+        url: response.data.html_url,
+        title: response.data.title,
+        nodeId: response.data.node_id
+      };
+    } catch (error) {
+      logger.error("Failed to create issue", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error),
+        context: { title, owner, repo }
+      });
+      return null;
+    } finally {
+      this.client.invalidateCache(`issues:${owner}:${repo}`);
+      this.client.invalidateCache("context:");
+    }
+  }
+  async closeIssue(owner, repo, issueNumber, comment) {
+    if (!this.client.octokit) {
+      logger.error("Cannot close issue: GitHub API not available", { module: "GitHub" });
+      return null;
+    }
+    try {
+      if (comment) {
+        await this.client.octokit.issues.createComment({
+          owner,
+          repo,
+          issue_number: issueNumber,
+          body: comment
+        });
+      }
+      const response = await this.client.octokit.issues.update({
+        owner,
+        repo,
+        issue_number: issueNumber,
+        state: "closed"
+      });
+      logger.info("Closed GitHub issue", {
+        module: "GitHub",
+        entityId: issueNumber,
+        context: { owner, repo, hadComment: !!comment }
+      });
+      return {
+        success: true,
+        url: response.data.html_url
+      };
+    } catch (error) {
+      logger.error("Failed to close issue", {
+        module: "GitHub",
+        entityId: issueNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    } finally {
+      this.client.invalidateCache(`issues:${owner}:${repo}`);
+      this.client.invalidateCache(`issue:${owner}:${repo}:${String(issueNumber)}`);
+      this.client.invalidateCache("context:");
+    }
+  }
+};
+
+// src/github/github-integration/pull-requests.ts
+var PullRequestsManager = class _PullRequestsManager {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Known Copilot bot login patterns */
+  static COPILOT_BOT_PATTERNS = [
+    "copilot-pull-request-reviewer[bot]",
+    "github-copilot[bot]",
+    "copilot[bot]"
+  ];
+  async getPullRequests(owner, repo, state = "open", limit = 20) {
+    if (!this.client.octokit) {
+      return [];
+    }
+    const cacheKey = `prs:${owner}:${repo}:${state}:${String(limit)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.pulls.list({
+        owner,
+        repo,
+        state,
+        per_page: limit,
+        sort: "updated",
+        direction: "desc"
+      });
+      const result = response.data.map((pr) => ({
+        number: pr.number,
+        title: pr.title,
+        url: pr.html_url,
+        state: pr.merged_at ? "MERGED" : pr.state === "open" ? "OPEN" : "CLOSED"
+      }));
+      this.client.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error("Failed to get pull requests", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async getPullRequest(owner, repo, prNumber) {
+    if (!this.client.octokit) {
+      return null;
+    }
+    const cacheKey = `pr:${owner}:${repo}:${String(prNumber)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached !== void 0) return cached;
+    try {
+      const response = await this.client.octokit.pulls.get({
+        owner,
+        repo,
+        pull_number: prNumber
+      });
+      const pr = response.data;
+      const details = {
+        number: pr.number,
+        title: pr.title,
+        url: pr.html_url,
+        state: pr.merged_at ? "MERGED" : pr.state === "open" ? "OPEN" : "CLOSED",
+        body: pr.body,
+        draft: pr.draft ?? false,
+        headBranch: pr.head.ref,
+        baseBranch: pr.base.ref,
+        author: pr.user?.login ?? "unknown",
+        createdAt: pr.created_at,
+        updatedAt: pr.updated_at,
+        mergedAt: pr.merged_at,
+        closedAt: pr.closed_at,
+        additions: pr.additions,
+        deletions: pr.deletions,
+        changedFiles: pr.changed_files
+      };
+      this.client.setCache(cacheKey, details);
+      return details;
+    } catch (error) {
+      logger.error("Failed to get PR details", {
+        module: "GitHub",
+        entityId: prNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  static isCopilotAuthor(login) {
+    const lower = login.toLowerCase();
+    return _PullRequestsManager.COPILOT_BOT_PATTERNS.some(
+      (p) => lower === p || lower.includes("copilot")
+    );
+  }
+  async getReviews(owner, repo, prNumber) {
+    if (!this.client.octokit) return [];
+    const cacheKey = `reviews:${owner}:${repo}:${String(prNumber)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.rest.pulls.listReviews({
+        owner,
+        repo,
+        pull_number: prNumber,
+        per_page: 100
+      });
+      const reviews = response.data.map((r) => ({
+        id: r.id,
+        author: r.user?.login ?? "unknown",
+        state: r.state,
+        body: r.body ?? null,
+        submittedAt: r.submitted_at ?? r.commit_id ?? (/* @__PURE__ */ new Date()).toISOString(),
+        isCopilot: _PullRequestsManager.isCopilotAuthor(r.user?.login ?? "")
+      }));
+      this.client.setCache(cacheKey, reviews);
+      return reviews;
+    } catch (error) {
+      logger.error("Failed to get PR reviews", {
+        module: "GitHub",
+        entityId: prNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async getReviewComments(owner, repo, prNumber) {
+    if (!this.client.octokit) return [];
+    const cacheKey = `review-comments:${owner}:${repo}:${String(prNumber)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.rest.pulls.listReviewComments({
+        owner,
+        repo,
+        pull_number: prNumber,
+        per_page: 100
+      });
+      const comments = response.data.map((c) => ({
+        id: c.id,
+        author: c.user?.login ?? "unknown",
+        body: c.body,
+        path: c.path,
+        line: c.line ?? c.original_line ?? null,
+        side: c.side ?? "RIGHT",
+        createdAt: c.created_at,
+        isCopilot: _PullRequestsManager.isCopilotAuthor(c.user?.login ?? "")
+      }));
+      this.client.setCache(cacheKey, comments);
+      return comments;
+    } catch (error) {
+      logger.error("Failed to get review comments", {
+        module: "GitHub",
+        entityId: prNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async getCopilotReviewSummary(owner, repo, prNumber) {
+    const [reviews, comments] = await Promise.all([
+      this.getReviews(owner, repo, prNumber),
+      this.getReviewComments(owner, repo, prNumber)
+    ]);
+    const copilotReviews = reviews.filter((r) => r.isCopilot);
+    const copilotComments = comments.filter((c) => c.isCopilot);
+    let state = "none";
+    if (copilotReviews.length > 0) {
+      const latest = copilotReviews[copilotReviews.length - 1];
+      if (latest !== void 0) {
+        if (latest.state === "APPROVED") state = "approved";
+        else if (latest.state === "CHANGES_REQUESTED") state = "changes_requested";
+        else if (latest.state === "COMMENTED") state = "commented";
+      }
+    }
+    return {
+      prNumber,
+      state,
+      commentCount: copilotComments.length,
+      comments: copilotComments
+    };
+  }
+};
+
+// src/github/github-integration/projects.ts
+var ProjectsManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getProjectKanban(owner, projectNumber, repo) {
+    if (!this.client.graphqlWithAuth) {
+      logger.debug("GraphQL not available - no token", { module: "GitHub" });
+      return null;
+    }
+    const projectFragment = `
+            fragment ProjectData on ProjectV2 {
+                id
+                title
+                fields(first: 20) {
+                    nodes {
+                        ... on ProjectV2SingleSelectField {
+                            id
+                            name
+                            options {
+                                id
+                                name
+                                color
+                            }
+                        }
+                    }
+                }
+                items(first: 100) {
+                    nodes {
+                        id
+                        type
+                        createdAt
+                        updatedAt
+                        fieldValues(first: 10) {
+                            nodes {
+                                ... on ProjectV2ItemFieldSingleSelectValue {
+                                    name
+                                    field {
+                                        ... on ProjectV2SingleSelectField {
+                                            name
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        content {
+                            ... on Issue {
+                                number
+                                title
+                                url
+                                labels(first: 5) {
+                                    nodes { name }
+                                }
+                                assignees(first: 5) {
+                                    nodes { login }
+                                }
+                            }
+                            ... on PullRequest {
+                                number
+                                title
+                                url
+                                labels(first: 5) {
+                                    nodes { name }
+                                }
+                                assignees(first: 5) {
+                                    nodes { login }
+                                }
+                            }
+                            ... on DraftIssue {
+                                title
+                            }
+                        }
+                    }
+                }
+            }
+        `;
+    const userQuery = `
+            ${projectFragment}
+            query($owner: String!, $number: Int!) {
+                user(login: $owner) {
+                    projectV2(number: $number) {
+                        ...ProjectData
+                    }
+                }
+            }
+        `;
+    const repoQuery = `
+            ${projectFragment}
+            query($owner: String!, $repo: String!, $number: Int!) {
+                repository(owner: $owner, name: $repo) {
+                    projectV2(number: $number) {
+                        ...ProjectData
+                    }
+                }
+            }
+        `;
+    const orgQuery = `
+            ${projectFragment}
+            query($owner: String!, $number: Int!) {
+                organization(login: $owner) {
+                    projectV2(number: $number) {
+                        ...ProjectData
+                    }
+                }
+            }
+        `;
+    let project = null;
+    let source = "";
+    try {
+      const response = await this.client.graphqlWithAuth(userQuery, {
+        owner,
+        number: projectNumber
+      });
+      if (response.user?.projectV2) {
+        project = response.user.projectV2;
+        source = "user";
+      }
+    } catch {
+      logger.debug("User project not found, trying repository...", { module: "GitHub" });
+    }
+    if (!project && repo) {
+      try {
+        const response = await this.client.graphqlWithAuth(repoQuery, {
+          owner,
+          repo,
+          number: projectNumber
+        });
+        if (response.repository?.projectV2) {
+          project = response.repository.projectV2;
+          source = "repository";
+        }
+      } catch {
+        logger.debug("Repository project not found, trying organization...", {
+          module: "GitHub"
+        });
+      }
+    }
+    if (!project) {
+      try {
+        const response = await this.client.graphqlWithAuth(orgQuery, {
+          owner,
+          number: projectNumber
+        });
+        if (response.organization?.projectV2) {
+          project = response.organization.projectV2;
+          source = "organization";
+        }
+      } catch {
+        logger.debug("Organization project not found", { module: "GitHub" });
+      }
+    }
+    if (!project) {
+      logger.warning("Project not found", { module: "GitHub", entityId: projectNumber });
+      return null;
+    }
+    const statusField = project.fields.nodes.find(
+      (f) => f.name === "Status" && f.options !== void 0 && f.options.length > 0
+    );
+    if (!statusField?.id || !statusField.options) {
+      logger.warning("Status field not found in project", {
+        module: "GitHub",
+        entityId: projectNumber
+      });
+      return null;
+    }
+    const statusOptions = statusField.options.map((opt) => ({
+      id: opt.id,
+      name: opt.name,
+      color: opt.color
+    }));
+    const columnMap = /* @__PURE__ */ new Map();
+    for (const opt of statusOptions) {
+      columnMap.set(opt.name, []);
+    }
+    columnMap.set("No Status", []);
+    for (const item of project.items.nodes) {
+      const statusValue = item.fieldValues.nodes.find((fv) => fv.field?.name === "Status");
+      const status = statusValue?.name ?? "No Status";
+      const content = item.content;
+      const projectItem = {
+        id: item.id,
+        title: content?.title ?? "Draft Issue",
+        url: content?.url ?? "",
+        type: item.type,
+        status,
+        number: content?.number,
+        labels: content?.labels?.nodes.map((l) => l.name) ?? [],
+        assignees: content?.assignees?.nodes.map((a) => a.login) ?? [],
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt
+      };
+      const column = columnMap.get(status);
+      if (column) {
+        column.push(projectItem);
+      } else {
+        columnMap.get("No Status")?.push(projectItem);
+      }
+    }
+    const columns = [];
+    for (const opt of statusOptions) {
+      const items = columnMap.get(opt.name) ?? [];
+      columns.push({
+        status: opt.name,
+        statusOptionId: opt.id,
+        items
+      });
+    }
+    const noStatusItems = columnMap.get("No Status") ?? [];
+    if (noStatusItems.length > 0) {
+      columns.push({
+        status: "No Status",
+        statusOptionId: "",
+        items: noStatusItems
+      });
+    }
+    const totalItems = project.items.nodes.length;
+    logger.info("Fetched Kanban board", {
+      module: "GitHub",
+      entityId: projectNumber,
+      context: { columns: columns.length, items: totalItems, source }
+    });
+    return {
+      projectId: project.id,
+      projectNumber,
+      projectTitle: project.title,
+      statusFieldId: statusField.id,
+      statusOptions,
+      columns,
+      totalItems
+    };
+  }
+  async moveProjectItem(projectId, itemId, statusFieldId, statusOptionId) {
+    if (!this.client.graphqlWithAuth) {
+      return { success: false, error: "GraphQL not available - no token" };
+    }
+    try {
+      const mutation = `
+                mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+                    updateProjectV2ItemFieldValue(
+                        input: {
+                            projectId: $projectId
+                            itemId: $itemId
+                            fieldId: $fieldId
+                            value: { singleSelectOptionId: $optionId }
+                        }
+                    ) {
+                        projectV2Item {
+                            id
+                        }
+                    }
+                }
+            `;
+      await this.client.graphqlWithAuth(mutation, {
+        projectId,
+        itemId,
+        fieldId: statusFieldId,
+        optionId: statusOptionId
+      });
+      logger.info("Moved project item", {
+        module: "GitHub",
+        entityId: itemId,
+        context: { targetStatus: statusOptionId }
+      });
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error("Failed to move project item", {
+        module: "GitHub",
+        entityId: itemId,
+        error: errorMessage
+      });
+      return { success: false, error: errorMessage };
+    } finally {
+      this.client.invalidateCache("kanban:");
+    }
+  }
+  async addProjectItem(projectId, contentId) {
+    if (!this.client.graphqlWithAuth) {
+      return { success: false, error: "GraphQL not available - no token" };
+    }
+    try {
+      const mutation = `
+                mutation($projectId: ID!, $contentId: ID!) {
+                    addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+                        item {
+                            id
+                        }
+                    }
+                }
+            `;
+      const response = await this.client.graphqlWithAuth(mutation, {
+        projectId,
+        contentId
+      });
+      const itemId = response.addProjectV2ItemById?.item?.id;
+      logger.info("Added item to project", {
+        module: "GitHub",
+        context: { projectId, contentId, itemId }
+      });
+      return { success: true, itemId };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error("Failed to add item to project", {
+        module: "GitHub",
+        context: { projectId, contentId },
+        error: errorMessage
+      });
+      return { success: false, error: errorMessage };
+    } finally {
+      this.client.invalidateCache("kanban:");
+    }
+  }
+};
+
+// src/github/github-integration/milestones.ts
+var MilestonesManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getMilestones(owner, repo, state = "open", limit = 20) {
+    if (!this.client.octokit) {
+      return [];
+    }
+    const cacheKey = `milestones:${owner}:${repo}:${state}:${String(limit)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.issues.listMilestones({
+        owner,
+        repo,
+        state,
+        per_page: limit,
+        sort: "due_on",
+        direction: "asc"
+      });
+      const result = response.data.map((ms) => ({
+        number: ms.number,
+        title: ms.title,
+        description: ms.description ?? null,
+        state: ms.state === "open" ? "open" : "closed",
+        url: ms.html_url,
+        dueOn: ms.due_on ?? null,
+        openIssues: ms.open_issues,
+        closedIssues: ms.closed_issues,
+        createdAt: ms.created_at,
+        updatedAt: ms.updated_at,
+        creator: ms.creator?.login ?? null
+      }));
+      this.client.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error("Failed to get milestones", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async getMilestone(owner, repo, milestoneNumber) {
+    if (!this.client.octokit) {
+      return null;
+    }
+    const cacheKey = `milestone:${owner}:${repo}:${String(milestoneNumber)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached !== void 0) return cached;
+    try {
+      const response = await this.client.octokit.issues.getMilestone({
+        owner,
+        repo,
+        milestone_number: milestoneNumber
+      });
+      const ms = response.data;
+      const milestone = {
+        number: ms.number,
+        title: ms.title,
+        description: ms.description ?? null,
+        state: ms.state === "open" ? "open" : "closed",
+        url: ms.html_url,
+        dueOn: ms.due_on ?? null,
+        openIssues: ms.open_issues,
+        closedIssues: ms.closed_issues,
+        createdAt: ms.created_at,
+        updatedAt: ms.updated_at,
+        creator: ms.creator?.login ?? null
+      };
+      this.client.setCache(cacheKey, milestone);
+      return milestone;
+    } catch (error) {
+      logger.error("Failed to get milestone", {
+        module: "GitHub",
+        entityId: milestoneNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  async createMilestone(owner, repo, title, description, dueOn) {
+    if (!this.client.octokit) {
+      logger.error("Cannot create milestone: GitHub API not available", {
+        module: "GitHub"
+      });
+      return null;
+    }
+    try {
+      const response = await this.client.octokit.issues.createMilestone({
+        owner,
+        repo,
+        title,
+        description,
+        due_on: dueOn
+      });
+      const ms = response.data;
+      logger.info("Created GitHub milestone", {
+        module: "GitHub",
+        entityId: ms.number,
+        context: { title, owner, repo }
+      });
+      return {
+        number: ms.number,
+        title: ms.title,
+        description: ms.description ?? null,
+        state: ms.state === "open" ? "open" : "closed",
+        url: ms.html_url,
+        dueOn: ms.due_on ?? null,
+        openIssues: ms.open_issues,
+        closedIssues: ms.closed_issues,
+        createdAt: ms.created_at,
+        updatedAt: ms.updated_at,
+        creator: ms.creator?.login ?? null
+      };
+    } catch (error) {
+      logger.error("Failed to create milestone", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error),
+        context: { title, owner, repo }
+      });
+      return null;
+    } finally {
+      this.client.invalidateCache(`milestones:${owner}:${repo}`);
+      this.client.invalidateCache("context:");
+    }
+  }
+  async updateMilestone(owner, repo, milestoneNumber, updates) {
+    if (!this.client.octokit) {
+      logger.error("Cannot update milestone: GitHub API not available", {
+        module: "GitHub"
+      });
+      return null;
+    }
+    try {
+      const response = await this.client.octokit.issues.updateMilestone({
+        owner,
+        repo,
+        milestone_number: milestoneNumber,
+        title: updates.title,
+        description: updates.description,
+        due_on: updates.dueOn === null ? void 0 : updates.dueOn,
+        state: updates.state
+      });
+      const ms = response.data;
+      logger.info("Updated GitHub milestone", {
+        module: "GitHub",
+        entityId: milestoneNumber,
+        context: { owner, repo, updates: Object.keys(updates) }
+      });
+      return {
+        number: ms.number,
+        title: ms.title,
+        description: ms.description ?? null,
+        state: ms.state === "open" ? "open" : "closed",
+        url: ms.html_url,
+        dueOn: ms.due_on ?? null,
+        openIssues: ms.open_issues,
+        closedIssues: ms.closed_issues,
+        createdAt: ms.created_at,
+        updatedAt: ms.updated_at,
+        creator: ms.creator?.login ?? null
+      };
+    } catch (error) {
+      logger.error("Failed to update milestone", {
+        module: "GitHub",
+        entityId: milestoneNumber,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    } finally {
+      this.client.invalidateCache(`milestones:${owner}:${repo}`);
+      this.client.invalidateCache(`milestone:${owner}:${repo}:${String(milestoneNumber)}`);
+      this.client.invalidateCache("context:");
+    }
+  }
+  async deleteMilestone(owner, repo, milestoneNumber) {
+    if (!this.client.octokit) {
+      return { success: false, error: "GitHub API not available" };
+    }
+    try {
+      await this.client.octokit.issues.deleteMilestone({
+        owner,
+        repo,
+        milestone_number: milestoneNumber
+      });
+      logger.info("Deleted GitHub milestone", {
+        module: "GitHub",
+        entityId: milestoneNumber,
+        context: { owner, repo }
+      });
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error("Failed to delete milestone", {
+        module: "GitHub",
+        entityId: milestoneNumber,
+        error: errorMessage
+      });
+      return { success: false, error: errorMessage };
+    } finally {
+      this.client.invalidateCache(`milestones:${owner}:${repo}`);
+      this.client.invalidateCache(`milestone:${owner}:${repo}:${String(milestoneNumber)}`);
+      this.client.invalidateCache("context:");
+    }
+  }
+};
+
+// src/github/github-integration/insights.ts
+var InsightsManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getRepoStats(owner, repo) {
+    if (!this.client.octokit) {
+      return null;
+    }
+    const cacheKey = `repostats:${owner}:${repo}`;
+    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.repos.get({ owner, repo });
+      const data = response.data;
+      const result = {
+        stars: data.stargazers_count,
+        forks: data.forks_count,
+        watchers: data.subscribers_count,
+        openIssues: data.open_issues_count,
+        size: data.size,
+        defaultBranch: data.default_branch
+      };
+      this.client.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error("Failed to get repo stats", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error),
+        context: { owner, repo }
+      });
+      return null;
+    }
+  }
+  async getTrafficData(owner, repo) {
+    if (!this.client.octokit) {
+      return null;
+    }
+    const cacheKey = `traffic:${owner}:${repo}`;
+    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
+    if (cached) return cached;
+    try {
+      const [clonesRes, viewsRes] = await Promise.all([
+        this.client.octokit.rest.repos.getClones({ owner, repo }),
+        this.client.octokit.rest.repos.getViews({ owner, repo })
+      ]);
+      const clonesDays = clonesRes.data.clones?.length ?? 0;
+      const viewsDays = viewsRes.data.views?.length ?? 0;
+      const result = {
+        clones: {
+          total: clonesRes.data.count,
+          unique: clonesRes.data.uniques,
+          dailyAvg: clonesDays > 0 ? Math.round(clonesRes.data.count / clonesDays) : 0
+        },
+        views: {
+          total: viewsRes.data.count,
+          unique: viewsRes.data.uniques,
+          dailyAvg: viewsDays > 0 ? Math.round(viewsRes.data.count / viewsDays) : 0
+        },
+        period: "14 days"
+      };
+      this.client.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error("Failed to get traffic data", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error),
+        context: { owner, repo }
+      });
+      return null;
+    }
+  }
+  async getTopReferrers(owner, repo, limit = 5) {
+    if (!this.client.octokit) {
+      return [];
+    }
+    const cacheKey = `referrers:${owner}:${repo}`;
+    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
+    if (cached) return cached.slice(0, limit);
+    try {
+      const response = await this.client.octokit.rest.repos.getTopReferrers({ owner, repo });
+      const result = response.data.map((r) => ({
+        referrer: r.referrer,
+        count: r.count,
+        uniques: r.uniques
+      }));
+      this.client.setCache(cacheKey, result);
+      return result.slice(0, limit);
+    } catch (error) {
+      logger.error("Failed to get top referrers", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error),
+        context: { owner, repo }
+      });
+      return [];
+    }
+  }
+  async getPopularPaths(owner, repo, limit = 5) {
+    if (!this.client.octokit) {
+      return [];
+    }
+    const cacheKey = `paths:${owner}:${repo}`;
+    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
+    if (cached) return cached.slice(0, limit);
+    try {
+      const response = await this.client.octokit.rest.repos.getTopPaths({ owner, repo });
+      const result = response.data.map((p) => ({
+        path: p.path,
+        title: p.title,
+        count: p.count,
+        uniques: p.uniques
+      }));
+      this.client.setCache(cacheKey, result);
+      return result.slice(0, limit);
+    } catch (error) {
+      logger.error("Failed to get popular paths", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error),
+        context: { owner, repo }
+      });
+      return [];
+    }
+  }
+};
+
+// src/github/github-integration/repository.ts
+var RepositoryManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getRepoInfo() {
+    try {
+      const branchResult = await this.client.git.branch();
+      const branch = branchResult.current || null;
+      const remotes = await this.client.git.getRemotes(true);
+      const origin = remotes.find((r) => r.name === "origin");
+      const remoteUrl = origin?.refs?.fetch || null;
+      const { owner, repo } = this.parseRemoteUrl(remoteUrl);
+      const repoInfo = { owner, repo, branch, remoteUrl };
+      this.client.cachedRepoInfo = repoInfo;
+      return repoInfo;
+    } catch (error) {
+      logger.debug("Failed to get repo info (may not be a git repo)", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return { owner: null, repo: null, branch: null, remoteUrl: null };
+    }
+  }
+  getCachedRepoInfo() {
+    return this.client.cachedRepoInfo;
+  }
+  setCachedRepoInfo(info) {
+    this.client.cachedRepoInfo = info;
+  }
+  parseRemoteUrl(remoteUrl) {
+    if (!remoteUrl) return { owner: null, repo: null };
+    if (remoteUrl.startsWith("git@github.com:")) {
+      const pathPart = remoteUrl.replace("git@github.com:", "").replace(".git", "");
+      const parts = pathPart.split("/");
+      if (parts.length >= 2) {
+        return { owner: parts[0] ?? null, repo: parts[1] ?? null };
+      }
+    }
+    try {
+      const url = new URL(remoteUrl);
+      if (url.hostname === "github.com") {
+        const path = url.pathname.replace(".git", "").replace(/^\//, "");
+        const parts = path.split("/");
+        if (parts.length >= 2) {
+          return { owner: parts[0] ?? null, repo: parts[1] ?? null };
+        }
+      }
+    } catch {
+    }
+    return { owner: null, repo: null };
+  }
+  async getWorkflowRuns(owner, repo, limit = 10) {
+    if (!this.client.octokit) {
+      logger.debug("GitHub API not available - no token", { module: "GitHub" });
+      return [];
+    }
+    const cacheKey = `workflows:${owner}:${repo}:${String(limit)}`;
+    const cached = this.client.getCached(cacheKey);
+    if (cached) return cached;
+    try {
+      const response = await this.client.octokit.rest.actions.listWorkflowRunsForRepo({
+        owner,
+        repo,
+        per_page: limit
+      });
+      const result = response.data.workflow_runs.map((run) => ({
+        id: run.id,
+        name: run.name ?? "Unknown Workflow",
+        status: run.status,
+        conclusion: run.conclusion,
+        url: run.html_url,
+        headBranch: run.head_branch ?? "",
+        headSha: run.head_sha,
+        createdAt: run.created_at,
+        updatedAt: run.updated_at
+      }));
+      this.client.setCache(cacheKey, result);
+      return result;
+    } catch (error) {
+      logger.error("Failed to get workflow runs", {
+        module: "GitHub",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+};
+
+// src/github/github-integration/index.ts
+var GitHubIntegration = class {
+  client;
+  issuesManager;
+  pullRequestsManager;
+  projectsManager;
+  milestonesManager;
+  insightsManager;
+  repositoryManager;
+  constructor(workingDir = ".") {
+    this.client = new GitHubClient(workingDir);
+    this.issuesManager = new IssuesManager(this.client);
+    this.pullRequestsManager = new PullRequestsManager(this.client);
+    this.projectsManager = new ProjectsManager(this.client);
+    this.milestonesManager = new MilestonesManager(this.client);
+    this.insightsManager = new InsightsManager(this.client);
+    this.repositoryManager = new RepositoryManager(this.client);
+  }
+  isApiAvailable() {
+    return this.client.isApiAvailable();
+  }
+  clearCache() {
+    this.client.clearCache();
+  }
+  async getRepoInfo() {
+    return this.repositoryManager.getRepoInfo();
+  }
+  getCachedRepoInfo() {
+    return this.repositoryManager.getCachedRepoInfo();
+  }
+  setCachedRepoInfo(info) {
+    this.repositoryManager.setCachedRepoInfo(info);
+  }
+  async getIssues(owner, repo, state = "open", limit = 20) {
+    return this.issuesManager.getIssues(owner, repo, state, limit);
+  }
+  async getIssue(owner, repo, issueNumber) {
+    return this.issuesManager.getIssue(owner, repo, issueNumber);
+  }
+  async createIssue(owner, repo, title, body, labels, assignees, milestone) {
+    return this.issuesManager.createIssue(
+      owner,
+      repo,
+      title,
+      body,
+      labels,
+      assignees,
+      milestone
+    );
+  }
+  async closeIssue(owner, repo, issueNumber, comment) {
+    return this.issuesManager.closeIssue(owner, repo, issueNumber, comment);
+  }
+  async getPullRequests(owner, repo, state = "open", limit = 20) {
+    return this.pullRequestsManager.getPullRequests(owner, repo, state, limit);
+  }
+  async getPullRequest(owner, repo, prNumber) {
+    return this.pullRequestsManager.getPullRequest(owner, repo, prNumber);
+  }
+  async getReviews(owner, repo, prNumber) {
+    return this.pullRequestsManager.getReviews(owner, repo, prNumber);
+  }
+  async getReviewComments(owner, repo, prNumber) {
+    return this.pullRequestsManager.getReviewComments(owner, repo, prNumber);
+  }
+  async getCopilotReviewSummary(owner, repo, prNumber) {
+    return this.pullRequestsManager.getCopilotReviewSummary(owner, repo, prNumber);
+  }
+  async getWorkflowRuns(owner, repo, limit = 10) {
+    return this.repositoryManager.getWorkflowRuns(owner, repo, limit);
+  }
+  async getRepoContext() {
+    const cached = this.client.getCached("context:repo");
+    if (cached) return cached;
+    const repoInfo = await this.repositoryManager.getRepoInfo();
+    const context = {
+      repoName: repoInfo.repo,
+      branch: repoInfo.branch,
+      commit: null,
+      remoteUrl: repoInfo.remoteUrl,
+      projects: [],
+      issues: [],
+      pullRequests: [],
+      workflowRuns: [],
+      milestones: []
+    };
+    try {
+      const log = await this.client.git.log({ maxCount: 1 });
+      context.commit = log.latest?.hash ?? null;
+    } catch {
+    }
+    if (repoInfo.owner && repoInfo.repo) {
+      context.issues = await this.issuesManager.getIssues(
+        repoInfo.owner,
+        repoInfo.repo,
+        "open",
+        10
+      );
+      context.pullRequests = await this.pullRequestsManager.getPullRequests(
+        repoInfo.owner,
+        repoInfo.repo,
+        "open",
+        10
+      );
+      context.workflowRuns = await this.repositoryManager.getWorkflowRuns(
+        repoInfo.owner,
+        repoInfo.repo,
+        10
+      );
+      context.milestones = await this.milestonesManager.getMilestones(
+        repoInfo.owner,
+        repoInfo.repo,
+        "open",
+        10
+      );
+    }
+    this.client.setCache("context:repo", context);
+    return context;
+  }
+  async getProjectKanban(owner, projectNumber, repo) {
+    return this.projectsManager.getProjectKanban(owner, projectNumber, repo);
+  }
+  async moveProjectItem(projectId, itemId, statusFieldId, statusOptionId) {
+    return this.projectsManager.moveProjectItem(
+      projectId,
+      itemId,
+      statusFieldId,
+      statusOptionId
+    );
+  }
+  async addProjectItem(projectId, contentId) {
+    return this.projectsManager.addProjectItem(projectId, contentId);
+  }
+  async getMilestones(owner, repo, state = "open", limit = 20) {
+    return this.milestonesManager.getMilestones(owner, repo, state, limit);
+  }
+  async getMilestone(owner, repo, milestoneNumber) {
+    return this.milestonesManager.getMilestone(owner, repo, milestoneNumber);
+  }
+  async createMilestone(owner, repo, title, description, dueOn) {
+    return this.milestonesManager.createMilestone(owner, repo, title, description, dueOn);
+  }
+  async updateMilestone(owner, repo, milestoneNumber, updates) {
+    return this.milestonesManager.updateMilestone(owner, repo, milestoneNumber, updates);
+  }
+  async deleteMilestone(owner, repo, milestoneNumber) {
+    return this.milestonesManager.deleteMilestone(owner, repo, milestoneNumber);
+  }
+  async getRepoStats(owner, repo) {
+    return this.insightsManager.getRepoStats(owner, repo);
+  }
+  async getTrafficData(owner, repo) {
+    return this.insightsManager.getTrafficData(owner, repo);
+  }
+  async getTopReferrers(owner, repo, limit = 5) {
+    return this.insightsManager.getTopReferrers(owner, repo, limit);
+  }
+  async getPopularPaths(owner, repo, limit = 5) {
+    return this.insightsManager.getPopularPaths(owner, repo, limit);
+  }
+};
+
+export { ConfigurationError, ConnectionError, GitHubIntegration, MemoryJournalMcpError, QueryError, ResourceNotFoundError, ValidationError, assertNoPathTraversal, logger, matchSuggestion, resolveAuthor, validateDateFormatPattern };