memory-journal-mcp 7.4.0 → 7.6.0

package/dist/chunk-WXDEVIFL.js

@@ -1,1745 +0,0 @@
-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_ERROR"
-  },
-  // 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_ERROR"
-  },
-  // 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_ERROR"
-  },
-  {
-    pattern: /^Missing required parameters:/i,
-    suggestion: "Provide all required parameters in your request.",
-    code: "VALIDATION_ERROR"
-  },
-  // 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_ERROR"
-  },
-  {
-    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_ERROR", "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);
-  }
-}
-function assertSafeDirectoryPath(dirPath) {
-  const normalized = dirPath.replace(/\\/g, "/");
-  const segments = normalized.split("/");
-  if (segments.some((s) => s === "..")) {
-    throw new PathTraversalError(dirPath);
-  }
-}
-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 getIssueComments(owner, repo, issueNumber, limit = 30) {
-    const _limit = Math.min(limit, 100);
-    if (_limit <= 0) return [];
-    if (!this.client.octokit) {
-      return [];
-    }
-    const cacheKey = `issue-comments:${owner}:${repo}:${String(issueNumber)}:${String(_limit)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.issues.listComments({
-        owner,
-        repo,
-        issue_number: issueNumber,
-        per_page: _limit,
-        sort: "created",
-        direction: "asc"
-      });
-      const comments = response.data.slice(0, _limit).map((comment) => ({
-        author: comment.user?.login ?? "unknown",
-        body: comment.body ?? "",
-        createdAt: comment.created_at
-      }));
-      this.client.setCache(cacheKey, comments);
-      return comments;
-    } catch (error) {
-      logger.error("Failed to get issue comments", {
-        module: "GitHub",
-        entityId: issueNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    }
-  }
-  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 {
-      if (typeof this.client.invalidateCache === "function") {
-        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 {
-      if (typeof this.client.invalidateCache === "function") {
-        this.client.invalidateCache("kanban:");
-      }
-    }
-  }
-  async deleteProjectItem(projectId, itemId) {
-    if (!this.client.graphqlWithAuth) {
-      return { success: false, error: "GraphQL not available - no token" };
-    }
-    try {
-      const mutation = `
-                mutation($projectId: ID!, $itemId: ID!) {
-                    deleteProjectV2Item(input: { projectId: $projectId, itemId: $itemId }) {
-                        deletedItemId
-                    }
-                }
-            `;
-      await this.client.graphqlWithAuth(mutation, {
-        projectId,
-        itemId
-      });
-      logger.info("Deleted project item", {
-        module: "GitHub",
-        context: { projectId, itemId }
-      });
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Failed to delete item from project", {
-        module: "GitHub",
-        context: { projectId, itemId },
-        error: errorMessage
-      });
-      return { success: false, error: errorMessage };
-    } finally {
-      if (typeof this.client.invalidateCache === "function") {
-        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 getIssueComments(owner, repo, issueNumber, limit = 30) {
-    return this.issuesManager.getIssueComments(owner, repo, issueNumber, limit);
-  }
-  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 deleteProjectItem(projectId, itemId) {
-    return this.projectsManager.deleteProjectItem(projectId, itemId);
-  }
-  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, assertSafeDirectoryPath, logger, matchSuggestion, resolveAuthor, validateDateFormatPattern };