gh-manager-cli 1.16.1 → 1.17.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.17.0](https://github.com/wiiiimm/gh-manager-cli/compare/v1.16.1...v1.17.0) (2025-09-02)
+
+
+### Features
+
+* implement comprehensive logging system ([#17](https://github.com/wiiiimm/gh-manager-cli/issues/17)) ([a447ce1](https://github.com/wiiiimm/gh-manager-cli/commit/a447ce1287be86ce20830ddd96fa9d20ae22743e))
+
 ## [1.16.1](https://github.com/wiiiimm/gh-manager-cli/compare/v1.16.0...v1.16.1) (2025-09-02)
 
 

package/dist/{chunk-OKP742N4.js → chunk-FPJS7YJW.js}

@@ -29,9 +29,177 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 import { graphql as makeGraphQL } from "@octokit/graphql";
 import { ApolloClient, InMemoryCache, HttpLink, gql } from "@apollo/client/core/index.js";
 import { persistCache } from "apollo3-cache-persist";
+import fs2 from "fs";
+import path2 from "path";
+import envPaths2 from "env-paths";
+
+// src/logger.ts
 import fs from "fs";
 import path from "path";
 import envPaths from "env-paths";
+var LOG_COLOURS = {
+  [0 /* DEBUG */]: "\x1B[36m",
+  // Cyan
+  [1 /* INFO */]: "\x1B[37m",
+  // White
+  [2 /* WARN */]: "\x1B[33m",
+  // Yellow
+  [3 /* ERROR */]: "\x1B[31m",
+  // Red
+  [4 /* FATAL */]: "\x1B[35m"
+  // Magenta
+};
+var RESET_COLOUR = "\x1B[0m";
+var Logger = class _Logger {
+  constructor(config = {}) {
+    this.logLevel = config.logLevel ?? (process.env.GH_MANAGER_DEBUG === "1" ? 0 /* DEBUG */ : 1 /* INFO */);
+    this.logToFile = config.logToFile ?? true;
+    this.logToConsole = config.logToConsole ?? process.env.GH_MANAGER_DEBUG === "1";
+    this.maxFileSize = config.maxFileSize ?? 5 * 1024 * 1024;
+    this.maxFiles = config.maxFiles ?? 5;
+    const paths = envPaths("gh-manager-cli", { suffix: "" });
+    this.logDir = config.logDir ?? paths.log;
+    if (this.logToFile) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+      this.logFile = path.join(this.logDir, "gh-manager-cli.log");
+      this.initLogFile();
+    } else {
+      this.logFile = "";
+    }
+  }
+  static getInstance(config) {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger(config);
+    }
+    return _Logger.instance;
+  }
+  initLogFile() {
+    try {
+      if (fs.existsSync(this.logFile)) {
+        const stats = fs.statSync(this.logFile);
+        if (stats.size >= this.maxFileSize) {
+          this.rotateLogFiles();
+        }
+      }
+      this.writeStream = fs.createWriteStream(this.logFile, { flags: "a" });
+    } catch (error) {
+      this.logToFile = false;
+      console.error("Failed to initialise log file:", error);
+    }
+  }
+  rotateLogFiles() {
+    try {
+      if (this.writeStream) {
+        this.writeStream.end();
+      }
+      for (let i = this.maxFiles - 1; i > 0; i--) {
+        const oldFile = i === 1 ? this.logFile : `${this.logFile}.${i - 1}`;
+        const newFile = `${this.logFile}.${i}`;
+        if (fs.existsSync(oldFile)) {
+          if (fs.existsSync(newFile)) {
+            fs.unlinkSync(newFile);
+          }
+          fs.renameSync(oldFile, newFile);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to rotate log files:", error);
+    }
+  }
+  formatTimestamp() {
+    const now = /* @__PURE__ */ new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const seconds = String(now.getSeconds()).padStart(2, "0");
+    const ms = String(now.getMilliseconds()).padStart(3, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+  }
+  getLevelName(level) {
+    const names = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"];
+    return names[level] || "UNKNOWN";
+  }
+  formatMessage(level, message, context) {
+    const timestamp = this.formatTimestamp();
+    const levelName = this.getLevelName(level);
+    const paddedLevel = levelName.padEnd(5);
+    let formattedMessage = `[${timestamp}] [${paddedLevel}] ${message}`;
+    if (context !== void 0) {
+      try {
+        const contextStr = typeof context === "object" ? JSON.stringify(context, null, 2) : String(context);
+        formattedMessage += `
+${contextStr}`;
+      } catch (error) {
+        formattedMessage += "\n[Unable to serialise context]";
+      }
+    }
+    return formattedMessage;
+  }
+  log(level, message, context) {
+    if (level < this.logLevel) {
+      return;
+    }
+    const formattedMessage = this.formatMessage(level, message, context);
+    if (this.logToConsole) {
+      const colour = LOG_COLOURS[level];
+      console.log(`${colour}${formattedMessage}${RESET_COLOUR}`);
+    }
+    if (this.logToFile && this.writeStream) {
+      this.writeStream.write(formattedMessage + "\n");
+      const stats = fs.statSync(this.logFile);
+      if (stats.size >= this.maxFileSize) {
+        this.rotateLogFiles();
+        this.initLogFile();
+      }
+    }
+  }
+  debug(message, context) {
+    this.log(0 /* DEBUG */, message, context);
+  }
+  info(message, context) {
+    this.log(1 /* INFO */, message, context);
+  }
+  warn(message, context) {
+    this.log(2 /* WARN */, message, context);
+  }
+  error(message, context) {
+    this.log(3 /* ERROR */, message, context);
+  }
+  fatal(message, context) {
+    this.log(4 /* FATAL */, message, context);
+  }
+  // Method to get log file path
+  getLogFilePath() {
+    return this.logFile;
+  }
+  // Method to get all log files
+  getLogFiles() {
+    if (!this.logToFile) return [];
+    const files = [];
+    if (fs.existsSync(this.logFile)) {
+      files.push(this.logFile);
+    }
+    for (let i = 1; i < this.maxFiles; i++) {
+      const rotatedFile = `${this.logFile}.${i}`;
+      if (fs.existsSync(rotatedFile)) {
+        files.push(rotatedFile);
+      }
+    }
+    return files;
+  }
+  // Clean up method
+  close() {
+    if (this.writeStream) {
+      this.writeStream.end();
+      this.writeStream = void 0;
+    }
+  }
+};
+var logger = Logger.getInstance();
+
+// src/github.ts
 function makeClient(token) {
   return makeGraphQL.defaults({
     headers: { authorization: `token ${token}` }
@@ -50,22 +218,22 @@ async function makeApolloClient(token) {
     const storage = {
       async getItem(key) {
         try {
-          const p = envPaths("gh-manager-cli").data;
-          const file = path.join(p, "apollo-cache.json");
-          return fs.readFileSync(file, "utf8");
+          const p = envPaths2("gh-manager-cli").data;
+          const file = path2.join(p, "apollo-cache.json");
+          return fs2.readFileSync(file, "utf8");
         } catch {
           return null;
         }
       },
       async setItem(key, value) {
         try {
-          const p = envPaths("gh-manager-cli").data;
-          fs.mkdirSync(p, { recursive: true });
-          const file = path.join(p, "apollo-cache.json");
-          fs.writeFileSync(file, value, "utf8");
+          const p = envPaths2("gh-manager-cli").data;
+          fs2.mkdirSync(p, { recursive: true });
+          const file = path2.join(p, "apollo-cache.json");
+          fs2.writeFileSync(file, value, "utf8");
           if (process.platform !== "win32") {
             try {
-              fs.chmodSync(file, 384);
+              fs2.chmodSync(file, 384);
             } catch {
             }
           }
@@ -74,9 +242,9 @@ async function makeApolloClient(token) {
       },
       async removeItem(key) {
         try {
-          const p = envPaths("gh-manager-cli").data;
-          const file = path.join(p, "apollo-cache.json");
-          fs.unlinkSync(file);
+          const p = envPaths2("gh-manager-cli").data;
+          const file = path2.join(p, "apollo-cache.json");
+          fs2.unlinkSync(file);
         } catch {
         }
       }
@@ -91,6 +259,10 @@ async function makeApolloClient(token) {
     apolloClientInstance = { client, gql };
     return apolloClientInstance;
   } catch (error) {
+    logger.error("Failed to initialize Apollo Client", {
+      error: error.message,
+      stack: error.stack
+    });
     const debug = process.env.GH_MANAGER_DEBUG === "1";
     if (debug) {
       process.stderr.write(`
@@ -115,8 +287,15 @@ async function getViewerLogin(client) {
     }
   `
   );
-  const res = await client(query);
-  return res.viewer.login;
+  try {
+    logger.debug("Fetching viewer login");
+    const res = await client(query);
+    logger.info(`Successfully fetched viewer login: ${res.viewer.login}`);
+    return res.viewer.login;
+  } catch (error) {
+    logger.error("Failed to fetch viewer login", { error: error.message, stack: error.stack });
+    throw error;
+  }
 }
 async function fetchViewerOrganizations(client) {
   const query = (
@@ -140,6 +319,9 @@ async function fetchViewerOrganizations(client) {
   return res.viewer.organizations.nodes;
 }
 async function checkOrganizationIsEnterprise(client, orgLogin) {
+  logger.info("Checking if organization is enterprise", {
+    orgLogin
+  });
   try {
     const query = (
       /* GraphQL */
@@ -154,12 +336,23 @@ async function checkOrganizationIsEnterprise(client, orgLogin) {
     `
     );
     const res = await client(query, { orgLogin });
-    return res.organization?.enterpriseOwners?.totalCount > 0;
+    const isEnterprise = res.organization?.enterpriseOwners?.totalCount > 0;
+    logger.info("Organization enterprise status checked", {
+      orgLogin,
+      isEnterprise
+    });
+    return isEnterprise;
   } catch (error) {
     return false;
   }
 }
 async function fetchViewerReposPage(client, first, after, orderBy, includeForkTracking = true, ownerAffiliations = ["OWNER"], organizationLogin, privacy) {
+  logger.debug("Using Octokit client for fetching repos", {
+    first,
+    after,
+    organizationLogin,
+    privacy
+  });
   const sortField = orderBy?.field || "UPDATED_AT";
   const sortDirection = orderBy?.direction || "DESC";
   const isOrgContext = !!organizationLogin;
@@ -245,7 +438,7 @@ async function fetchViewerReposPage(client, first, after, orderBy, includeForkTr
       }
     `
     );
-    const res2 = await client(query2, {
+    const res = await client(query2, {
       first,
       after: after ?? null,
       sortField,
@@ -253,13 +446,13 @@ async function fetchViewerReposPage(client, first, after, orderBy, includeForkTr
       orgLogin: organizationLogin,
       privacy: privacy ?? null
     });
-    const data2 = res2.organization.repositories;
+    const data = res.organization.repositories;
     return {
-      nodes: data2.nodes,
-      endCursor: data2.pageInfo.endCursor,
-      hasNextPage: data2.pageInfo.hasNextPage,
-      totalCount: data2.totalCount,
-      rateLimit: res2.rateLimit
+      nodes: data.nodes,
+      endCursor: data.pageInfo.endCursor,
+      hasNextPage: data.pageInfo.hasNextPage,
+      totalCount: data.totalCount,
+      rateLimit: res.rateLimit
     };
   }
   const query = (
@@ -344,33 +537,54 @@ async function fetchViewerReposPage(client, first, after, orderBy, includeForkTr
     }
   `
   );
-  const res = await client(query, {
-    first,
-    after: after ?? null,
-    sortField,
-    sortDirection,
-    affiliations: ownerAffiliations,
-    privacy: privacy ?? null
-  });
-  const data = res.viewer.repositories;
-  return {
-    nodes: data.nodes,
-    endCursor: data.pageInfo.endCursor,
-    hasNextPage: data.pageInfo.hasNextPage,
-    totalCount: data.totalCount,
-    rateLimit: res.rateLimit
-  };
+  try {
+    const res = await client(query, {
+      first,
+      after: after ?? null,
+      sortField,
+      sortDirection,
+      affiliations: ownerAffiliations,
+      privacy: privacy ?? null
+    });
+    const data = res.viewer.repositories;
+    logger.info(`Octokit successfully fetched ${data.nodes.length} repositories`);
+    return {
+      nodes: data.nodes,
+      endCursor: data.pageInfo.endCursor,
+      hasNextPage: data.pageInfo.hasNextPage,
+      totalCount: data.totalCount,
+      rateLimit: res.rateLimit
+    };
+  } catch (error) {
+    logger.error("Octokit query failed", {
+      error: error.message,
+      stack: error.stack,
+      status: error.status,
+      response: error.response
+    });
+    throw error;
+  }
 }
 async function fetchViewerReposPageUnified(token, first, after, orderBy, includeForkTracking = true, fetchPolicy = "cache-first", ownerAffiliations = ["OWNER"], organizationLogin, privacy) {
   const isApolloEnabled = true;
   const debug = process.env.GH_MANAGER_DEBUG === "1";
   const isOrgContext = !!organizationLogin;
+  logger.info("Fetching repositories", {
+    fetchPolicy,
+    isOrgContext,
+    organizationLogin,
+    first,
+    after,
+    privacy,
+    ownerAffiliations
+  });
   if (debug) {
     console.log(`\u{1F50D} Apollo enabled: ${isApolloEnabled}, Policy: ${fetchPolicy}, After: ${after || "null"}, Context: ${isOrgContext ? "Organization" : "Personal"}`);
   }
   try {
     if (isApolloEnabled) {
       if (debug) console.log("\u{1F680} Attempting Apollo Client...");
+      logger.debug("Attempting to use Apollo Client");
       const ap = await makeApolloClient(token);
       const sortField = orderBy?.field || "UPDATED_AT";
       const sortDirection = orderBy?.direction || "DESC";
@@ -446,18 +660,28 @@ async function fetchViewerReposPageUnified(token, first, after, orderBy, include
         `;
       }
       const startTime = Date.now();
+      logger.debug("Executing Apollo query", { variables });
       const res = await ap.client.query({
         query: q,
         variables,
         fetchPolicy
       });
       const duration = Date.now() - startTime;
+      logger.info(`Apollo query completed in ${duration}ms`, {
+        duration,
+        fromCache: res.loading === false && duration < 50,
+        networkStatus: res.networkStatus
+      });
       if (debug) {
         console.log(`\u26A1 Apollo query completed in ${duration}ms`);
         console.log(`\u{1F4CA} From cache: ${res.loading === false && duration < 50 ? "YES" : "NO"}`);
         console.log(`\u{1F504} Network status: ${res.networkStatus}`);
       }
       const data = isOrgContext ? res.data.organization.repositories : res.data.viewer.repositories;
+      logger.info(`Successfully fetched ${data.nodes.length} repositories`, {
+        totalCount: data.totalCount,
+        hasNextPage: data.pageInfo.hasNextPage
+      });
       return {
         nodes: data.nodes,
         endCursor: data.pageInfo.endCursor,
@@ -467,8 +691,15 @@ async function fetchViewerReposPageUnified(token, first, after, orderBy, include
       };
     }
   } catch (e) {
+    logger.error("Apollo query failed", {
+      error: e.message,
+      stack: e.stack,
+      graphQLErrors: e.graphQLErrors,
+      networkError: e.networkError
+    });
     if (debug) console.log(`\u274C Apollo failed, falling back to Octokit:`, e.message);
   }
+  logger.warn("Falling back to Octokit client");
   if (debug) console.log("\u{1F4E1} Using Octokit fallback...");
   const octo = makeClient(token);
   return fetchViewerReposPage(octo, first, after, orderBy, includeForkTracking, ownerAffiliations, organizationLogin, privacy);
@@ -543,6 +774,11 @@ async function searchRepositoriesUnified(token, viewer, text, first, after, sort
 }
 async function deleteRepositoryRest(token, owner, repo) {
   const url = `https://api.github.com/repos/${owner}/${repo}`;
+  logger.info("Deleting repository", {
+    owner,
+    repo,
+    url
+  });
   const res = await fetch(url, {
     method: "DELETE",
     headers: {
@@ -551,16 +787,32 @@ async function deleteRepositoryRest(token, owner, repo) {
       "User-Agent": "gh-manager-cli"
     }
   });
-  if (res.status === 204) return;
+  if (res.status === 204) {
+    logger.info("Successfully deleted repository", {
+      owner,
+      repo,
+      status: res.status
+    });
+    return;
+  }
   let msg = `GitHub REST delete failed (status ${res.status})`;
   try {
     const body = await res.json();
     if (body && body.message) msg += `: ${body.message}`;
   } catch {
   }
+  logger.error("Failed to delete repository", {
+    status: res.status,
+    error: msg,
+    owner,
+    repo
+  });
   throw new Error(msg);
 }
 async function archiveRepositoryById(client, repositoryId) {
+  logger.info("Archiving repository", {
+    repositoryId
+  });
   const mutation = (
     /* GraphQL */
     `
@@ -571,9 +823,24 @@ async function archiveRepositoryById(client, repositoryId) {
     }
   `
   );
-  await client(mutation, { repositoryId });
+  try {
+    await client(mutation, { repositoryId });
+    logger.info("Successfully archived repository", {
+      repositoryId
+    });
+  } catch (error) {
+    logger.error("Failed to archive repository", {
+      repositoryId,
+      error: error.message,
+      stack: error.stack
+    });
+    throw error;
+  }
 }
 async function unarchiveRepositoryById(client, repositoryId) {
+  logger.info("Unarchiving repository", {
+    repositoryId
+  });
   const mutation = (
     /* GraphQL */
     `
@@ -584,7 +851,19 @@ async function unarchiveRepositoryById(client, repositoryId) {
     }
   `
   );
-  await client(mutation, { repositoryId });
+  try {
+    await client(mutation, { repositoryId });
+    logger.info("Successfully unarchived repository", {
+      repositoryId
+    });
+  } catch (error) {
+    logger.error("Failed to unarchive repository", {
+      repositoryId,
+      error: error.message,
+      stack: error.stack
+    });
+    throw error;
+  }
 }
 async function changeRepositoryVisibility(client, repositoryId, visibility, token) {
   const query = (
@@ -624,8 +903,22 @@ async function changeRepositoryVisibility(client, repositoryId, visibility, toke
   });
   if (!response.ok) {
     const error = await response.text();
+    logger.error("Failed to change repository visibility", {
+      status: response.status,
+      statusText: response.statusText,
+      error,
+      owner,
+      name,
+      visibility
+    });
     throw new Error(`Failed to change visibility: ${error}`);
   }
+  logger.info("Successfully changed repository visibility", {
+    owner,
+    name,
+    newVisibility: visibility,
+    nameWithOwner: repo.nameWithOwner
+  });
   return { nameWithOwner: repo.nameWithOwner };
 }
 async function getRepositoryFromCache(token, repositoryId) {
@@ -742,6 +1035,12 @@ async function fetchRepositoryById(client, repositoryId, includeForkTracking = t
 }
 async function syncForkWithUpstream(token, owner, repo, branch = "main") {
   const url = `https://api.github.com/repos/${owner}/${repo}/merge-upstream`;
+  logger.info("Syncing fork with upstream", {
+    owner,
+    repo,
+    branch,
+    url
+  });
   const res = await fetch(url, {
     method: "POST",
     headers: {
@@ -752,10 +1051,24 @@ async function syncForkWithUpstream(token, owner, repo, branch = "main") {
     body: JSON.stringify({ branch })
   });
   if (res.status === 204) {
+    logger.info("Fork already up-to-date with upstream", {
+      owner,
+      repo,
+      branch,
+      status: res.status
+    });
     return { message: "Already up-to-date", merge_type: "none", base_branch: branch };
   }
   if (res.status === 200) {
     const body = await res.json();
+    logger.info("Successfully synced fork with upstream", {
+      owner,
+      repo,
+      branch,
+      status: res.status,
+      mergeType: body.merge_type,
+      message: body.message
+    });
     return body;
   }
   let msg = `Fork sync failed (status ${res.status})`;
@@ -772,25 +1085,32 @@ async function syncForkWithUpstream(token, owner, repo, branch = "main") {
     }
   } catch {
   }
+  logger.error("Failed to sync fork with upstream", {
+    status: res.status,
+    error: msg,
+    owner,
+    repo,
+    branch
+  });
   throw new Error(msg);
 }
 async function purgeApolloCacheFiles() {
   try {
-    const fs2 = await import("fs");
-    const path2 = await import("path");
-    const envPaths2 = (await import("env-paths")).default;
-    const p = envPaths2("gh-manager-cli").data;
-    const cacheFile = path2.join(p, "apollo-cache.json");
-    const metaFile = path2.join(p, "apollo-cache-meta.json");
+    const fs3 = await import("fs");
+    const path3 = await import("path");
+    const envPaths3 = (await import("env-paths")).default;
+    const p = envPaths3("gh-manager-cli").data;
+    const cacheFile = path3.join(p, "apollo-cache.json");
+    const metaFile = path3.join(p, "apollo-cache-meta.json");
     if (process.env.GH_MANAGER_DEBUG === "1") {
       console.log(`\u{1F5D1}\uFE0F  Purging cache files from: ${p}`);
     }
     try {
-      fs2.unlinkSync(cacheFile);
+      fs3.unlinkSync(cacheFile);
     } catch {
     }
     try {
-      fs2.unlinkSync(metaFile);
+      fs3.unlinkSync(metaFile);
     } catch {
     }
   } catch {
@@ -819,6 +1139,10 @@ async function updateCacheAfterArchive(token, repositoryId, isArchived) {
   }
 }
 async function updateCacheAfterVisibilityChange(token, repositoryId, visibility) {
+  logger.info("Updating cache after repository visibility change", {
+    repositoryId,
+    visibility
+  });
   try {
     const ap = await makeApolloClient(token);
     if (!ap || !ap.client) return;
@@ -889,17 +1213,17 @@ async function updateCacheWithRepository(token, repository) {
 }
 async function inspectCacheStatus() {
   try {
-    const fs2 = await import("fs");
-    const path2 = await import("path");
-    const envPaths2 = (await import("env-paths")).default;
-    const p = envPaths2("gh-manager-cli").data;
-    const cacheFile = path2.join(p, "apollo-cache.json");
-    const metaFile = path2.join(p, "apollo-cache-meta.json");
+    const fs3 = await import("fs");
+    const path3 = await import("path");
+    const envPaths3 = (await import("env-paths")).default;
+    const p = envPaths3("gh-manager-cli").data;
+    const cacheFile = path3.join(p, "apollo-cache.json");
+    const metaFile = path3.join(p, "apollo-cache-meta.json");
     process.stderr.write(`
 \u{1F4C2} Cache directory: ${p}
 `);
     try {
-      const cacheStats = fs2.statSync(cacheFile);
+      const cacheStats = fs3.statSync(cacheFile);
       process.stderr.write(`\u{1F4BE} Cache file: ${Math.round(cacheStats.size / 1024)}KB (${cacheStats.mtime.toISOString()})
 `);
     } catch {
@@ -907,8 +1231,8 @@ async function inspectCacheStatus() {
 `);
     }
     try {
-      const metaStats = fs2.statSync(metaFile);
-      const metaContent = fs2.readFileSync(metaFile, "utf8");
+      const metaStats = fs3.statSync(metaFile);
+      const metaContent = fs3.readFileSync(metaFile, "utf8");
       const meta = JSON.parse(metaContent);
       process.stderr.write(`\u{1F4CA} Meta file: ${Object.keys(meta.fetched || {}).length} entries (${metaStats.mtime.toISOString()})
 `);
@@ -935,6 +1259,7 @@ async function inspectCacheStatus() {
 export {
   __commonJS,
   __toESM,
+  logger,
   makeClient,
   getViewerLogin,
   fetchViewerOrganizations,

package/dist/{github-YDCON2PN.js → github-7RR5WPCN.js}

@@ -20,7 +20,7 @@ import {
   updateCacheAfterDelete,
   updateCacheAfterVisibilityChange,
   updateCacheWithRepository
-} from "./chunk-OKP742N4.js";
+} from "./chunk-FPJS7YJW.js";
 export {
   archiveRepositoryById,
   changeRepositoryVisibility,

package/dist/index.js

@@ -11,6 +11,7 @@ import {
   getRepositoryFromCache,
   getViewerLogin,
   inspectCacheStatus,
+  logger,
   makeClient,
   purgeApolloCacheFiles,
   searchRepositoriesUnified,
@@ -20,14 +21,14 @@ import {
   updateCacheAfterDelete,
   updateCacheAfterVisibilityChange,
   updateCacheWithRepository
-} from "./chunk-OKP742N4.js";
+} from "./chunk-FPJS7YJW.js";
 
 // package.json
 var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "gh-manager-cli",
-      version: "1.16.1",
+      version: "1.17.0",
       private: false,
       description: "Interactive CLI to manage your GitHub repos (personal) with Ink",
       license: "MIT",
@@ -484,7 +485,7 @@ function OrgSwitcher({ token, currentContext, onSelect, onClose }) {
     try {
       setLoading(true);
       setError(null);
-      const client = await import("./github-YDCON2PN.js").then((m) => m.makeClient(token));
+      const client = await import("./github-7RR5WPCN.js").then((m) => m.makeClient(token));
       const orgs = await fetchViewerOrganizations(client);
       setOrganizations(orgs);
       const entOrgs = /* @__PURE__ */ new Set();
@@ -1234,6 +1235,13 @@ function RepoList({ token, maxVisibleRows, onLogout, viewerLogin, onOrgContextCh
   };
   React10.useEffect(() => {
     addDebugMessage(`[RepoList] Component mounted`);
+    logger.info("RepoList component mounted", {
+      token: token ? "present" : "missing",
+      tokenLength: token?.length,
+      viewerLogin,
+      ownerContext,
+      prefsLoaded
+    });
   }, []);
   const terminalWidth = stdout?.columns ?? 80;
   const availableHeight = maxVisibleRows ?? 20;
@@ -1473,6 +1481,15 @@ function RepoList({ token, maxVisibleRows, onLogout, viewerLogin, onOrgContextCh
     "stars": "STARGAZERS"
   };
   const fetchPage = async (after, reset = false, isSortChange = false, overrideForkTracking, policy) => {
+    logger.info("fetchPage called", {
+      after,
+      reset,
+      isSortChange,
+      policy,
+      token: token ? "present" : "missing",
+      viewerLogin,
+      ownerContext
+    });
     if (isSortChange) {
       setSortingLoading(true);
     } else if (after && !reset) {
@@ -1534,6 +1551,14 @@ function RepoList({ token, maxVisibleRows, onLogout, viewerLogin, onOrgContextCh
       setRateLimit(page.rateLimit);
       setError(null);
     } catch (e) {
+      logger.error("Failed to fetch repositories in RepoList", {
+        error: e.message,
+        stack: e.stack,
+        graphQLErrors: e.graphQLErrors,
+        networkError: e.networkError,
+        statusCode: e.statusCode,
+        response: e.response
+      });
       setError("Failed to load repositories. Check network or token.");
     } finally {
       setLoading(false);
@@ -2928,6 +2953,11 @@ function App() {
         const login = await getViewerLogin(client);
         clearTimeout(timeoutId);
         setViewer(login);
+        logger.info("User authenticated successfully", {
+          user: login,
+          tokenSource,
+          tokenStored: !getStoredToken()
+        });
         setWasRateLimited(false);
         setRateLimitReset(null);
         if (!getStoredToken()) {
@@ -2999,6 +3029,10 @@ function App() {
     setMode("validating");
   };
   const handleLogout = () => {
+    logger.info("User logged out", {
+      previousUser: viewer,
+      tokenSource
+    });
     try {
       clearStoredToken();
     } catch {
@@ -3212,16 +3246,39 @@ Env:
 }
 if (process.env.GH_MANAGER_DEBUG === "1") {
   process.stderr.write("\u{1F41B} Debug mode enabled\n");
+  logger.debug("Debug mode enabled via GH_MANAGER_DEBUG");
 }
+logger.info("Starting gh-manager-cli", {
+  version: import_package.default?.version || "0.0.0",
+  node: process.version
+});
+var handleShutdown = (signal) => {
+  logger.info("Shutting down gh-manager-cli", {
+    signal,
+    uptime: process.uptime()
+  });
+  process.exit(0);
+};
+process.on("SIGINT", () => handleShutdown("SIGINT"));
+process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+process.on("exit", (code) => {
+  logger.info("gh-manager-cli exited", {
+    exitCode: code,
+    uptime: process.uptime()
+  });
+});
 process.on("uncaughtException", (err) => {
+  logger.fatal("Uncaught exception", { error: err.message, stack: err.stack });
   console.error("Unhandled error:", err.message || err);
   process.exit(1);
 });
 process.on("unhandledRejection", (reason) => {
+  logger.fatal("Unhandled rejection", { error: reason?.message || reason, stack: reason?.stack });
   console.error("Unhandled rejection:", reason?.message || reason);
   process.exit(1);
 });
-render(
+logger.debug("Rendering UI");
+var { unmount } = render(
   /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx18(App, {}),
     /* @__PURE__ */ jsx18(Text18, { color: "gray" })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gh-manager-cli",
-  "version": "1.16.1",
+  "version": "1.17.0",
   "private": false,
   "description": "Interactive CLI to manage your GitHub repos (personal) with Ink",
   "license": "MIT",