@rainhole/rain-code 1.1.0

package/dist/chunk-n0qaeaa5.js

@@ -0,0 +1,256 @@
+// @bun
+import {
+  require_dist_cjs
+} from "./chunk-xsq9ae7x.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/getHomeDir.js
+var require_getHomeDir = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getHomeDir = undefined;
+  var os_1 = __require("os");
+  var path_1 = __require("path");
+  var homeDirCache = {};
+  var getHomeDirCacheKey = () => {
+    if (process && process.geteuid) {
+      return `${process.geteuid()}`;
+    }
+    return "DEFAULT";
+  };
+  var getHomeDir = () => {
+    const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${path_1.sep}` } = process.env;
+    if (HOME)
+      return HOME;
+    if (USERPROFILE)
+      return USERPROFILE;
+    if (HOMEPATH)
+      return `${HOMEDRIVE}${HOMEPATH}`;
+    const homeDirCacheKey = getHomeDirCacheKey();
+    if (!homeDirCache[homeDirCacheKey])
+      homeDirCache[homeDirCacheKey] = (0, os_1.homedir)();
+    return homeDirCache[homeDirCacheKey];
+  };
+  exports.getHomeDir = getHomeDir;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/getSSOTokenFilepath.js
+var require_getSSOTokenFilepath = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getSSOTokenFilepath = undefined;
+  var crypto_1 = __require("crypto");
+  var path_1 = __require("path");
+  var getHomeDir_1 = require_getHomeDir();
+  var getSSOTokenFilepath = (id) => {
+    const hasher = (0, crypto_1.createHash)("sha1");
+    const cacheName = hasher.update(id).digest("hex");
+    return (0, path_1.join)((0, getHomeDir_1.getHomeDir)(), ".aws", "sso", "cache", `${cacheName}.json`);
+  };
+  exports.getSSOTokenFilepath = getSSOTokenFilepath;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/getSSOTokenFromFile.js
+var require_getSSOTokenFromFile = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getSSOTokenFromFile = exports.tokenIntercept = undefined;
+  var promises_1 = __require("fs/promises");
+  var getSSOTokenFilepath_1 = require_getSSOTokenFilepath();
+  exports.tokenIntercept = {};
+  var getSSOTokenFromFile = async (id) => {
+    if (exports.tokenIntercept[id]) {
+      return exports.tokenIntercept[id];
+    }
+    const ssoTokenFilepath = (0, getSSOTokenFilepath_1.getSSOTokenFilepath)(id);
+    const ssoTokenText = await (0, promises_1.readFile)(ssoTokenFilepath, "utf8");
+    return JSON.parse(ssoTokenText);
+  };
+  exports.getSSOTokenFromFile = getSSOTokenFromFile;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/readFile.js
+var require_readFile = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.readFile = exports.fileIntercept = exports.filePromises = undefined;
+  var promises_1 = __require("fs/promises");
+  exports.filePromises = {};
+  exports.fileIntercept = {};
+  var readFile = (path, options) => {
+    if (exports.fileIntercept[path] !== undefined) {
+      return exports.fileIntercept[path];
+    }
+    if (!exports.filePromises[path] || options?.ignoreCache) {
+      exports.filePromises[path] = (0, promises_1.readFile)(path, "utf8");
+    }
+    return exports.filePromises[path];
+  };
+  exports.readFile = readFile;
+});
+
+// node_modules/.bun/@smithy+shared-ini-file-loader@4.4.7/node_modules/@smithy/shared-ini-file-loader/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var getHomeDir = require_getHomeDir();
+  var getSSOTokenFilepath = require_getSSOTokenFilepath();
+  var getSSOTokenFromFile = require_getSSOTokenFromFile();
+  var path = __require("path");
+  var types = require_dist_cjs();
+  var readFile = require_readFile();
+  var ENV_PROFILE = "AWS_PROFILE";
+  var DEFAULT_PROFILE = "default";
+  var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
+  var CONFIG_PREFIX_SEPARATOR = ".";
+  var getConfigData = (data) => Object.entries(data).filter(([key]) => {
+    const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
+    if (indexOfSeparator === -1) {
+      return false;
+    }
+    return Object.values(types.IniSectionType).includes(key.substring(0, indexOfSeparator));
+  }).reduce((acc, [key, value]) => {
+    const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
+    const updatedKey = key.substring(0, indexOfSeparator) === types.IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
+    acc[updatedKey] = value;
+    return acc;
+  }, {
+    ...data.default && { default: data.default }
+  });
+  var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
+  var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path.join(getHomeDir.getHomeDir(), ".aws", "config");
+  var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
+  var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path.join(getHomeDir.getHomeDir(), ".aws", "credentials");
+  var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
+  var profileNameBlockList = ["__proto__", "profile __proto__"];
+  var parseIni = (iniData) => {
+    const map = {};
+    let currentSection;
+    let currentSubSection;
+    for (const iniLine of iniData.split(/\r?\n/)) {
+      const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim();
+      const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
+      if (isSection) {
+        currentSection = undefined;
+        currentSubSection = undefined;
+        const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
+        const matches = prefixKeyRegex.exec(sectionName);
+        if (matches) {
+          const [, prefix, , name] = matches;
+          if (Object.values(types.IniSectionType).includes(prefix)) {
+            currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
+          }
+        } else {
+          currentSection = sectionName;
+        }
+        if (profileNameBlockList.includes(sectionName)) {
+          throw new Error(`Found invalid profile name "${sectionName}"`);
+        }
+      } else if (currentSection) {
+        const indexOfEqualsSign = trimmedLine.indexOf("=");
+        if (![0, -1].includes(indexOfEqualsSign)) {
+          const [name, value] = [
+            trimmedLine.substring(0, indexOfEqualsSign).trim(),
+            trimmedLine.substring(indexOfEqualsSign + 1).trim()
+          ];
+          if (value === "") {
+            currentSubSection = name;
+          } else {
+            if (currentSubSection && iniLine.trimStart() === iniLine) {
+              currentSubSection = undefined;
+            }
+            map[currentSection] = map[currentSection] || {};
+            const key = currentSubSection ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR) : name;
+            map[currentSection][key] = value;
+          }
+        }
+      }
+    }
+    return map;
+  };
+  var swallowError$1 = () => ({});
+  var loadSharedConfigFiles = async (init = {}) => {
+    const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init;
+    const homeDir = getHomeDir.getHomeDir();
+    const relativeHomeDirPrefix = "~/";
+    let resolvedFilepath = filepath;
+    if (filepath.startsWith(relativeHomeDirPrefix)) {
+      resolvedFilepath = path.join(homeDir, filepath.slice(2));
+    }
+    let resolvedConfigFilepath = configFilepath;
+    if (configFilepath.startsWith(relativeHomeDirPrefix)) {
+      resolvedConfigFilepath = path.join(homeDir, configFilepath.slice(2));
+    }
+    const parsedFiles = await Promise.all([
+      readFile.readFile(resolvedConfigFilepath, {
+        ignoreCache: init.ignoreCache
+      }).then(parseIni).then(getConfigData).catch(swallowError$1),
+      readFile.readFile(resolvedFilepath, {
+        ignoreCache: init.ignoreCache
+      }).then(parseIni).catch(swallowError$1)
+    ]);
+    return {
+      configFile: parsedFiles[0],
+      credentialsFile: parsedFiles[1]
+    };
+  };
+  var getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(types.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
+  var swallowError = () => ({});
+  var loadSsoSessionData = async (init = {}) => readFile.readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
+  var mergeConfigFiles = (...files) => {
+    const merged = {};
+    for (const file of files) {
+      for (const [key, values] of Object.entries(file)) {
+        if (merged[key] !== undefined) {
+          Object.assign(merged[key], values);
+        } else {
+          merged[key] = values;
+        }
+      }
+    }
+    return merged;
+  };
+  var parseKnownFiles = async (init) => {
+    const parsedFiles = await loadSharedConfigFiles(init);
+    return mergeConfigFiles(parsedFiles.configFile, parsedFiles.credentialsFile);
+  };
+  var externalDataInterceptor = {
+    getFileRecord() {
+      return readFile.fileIntercept;
+    },
+    interceptFile(path2, contents) {
+      readFile.fileIntercept[path2] = Promise.resolve(contents);
+    },
+    getTokenRecord() {
+      return getSSOTokenFromFile.tokenIntercept;
+    },
+    interceptToken(id, contents) {
+      getSSOTokenFromFile.tokenIntercept[id] = contents;
+    }
+  };
+  exports.getSSOTokenFromFile = getSSOTokenFromFile.getSSOTokenFromFile;
+  exports.readFile = readFile.readFile;
+  exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
+  exports.DEFAULT_PROFILE = DEFAULT_PROFILE;
+  exports.ENV_PROFILE = ENV_PROFILE;
+  exports.externalDataInterceptor = externalDataInterceptor;
+  exports.getProfileName = getProfileName;
+  exports.loadSharedConfigFiles = loadSharedConfigFiles;
+  exports.loadSsoSessionData = loadSsoSessionData;
+  exports.parseKnownFiles = parseKnownFiles;
+  Object.prototype.hasOwnProperty.call(getHomeDir, "__proto__") && !Object.prototype.hasOwnProperty.call(exports, "__proto__") && Object.defineProperty(exports, "__proto__", {
+    enumerable: true,
+    value: getHomeDir["__proto__"]
+  });
+  Object.keys(getHomeDir).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      exports[k] = getHomeDir[k];
+  });
+  Object.prototype.hasOwnProperty.call(getSSOTokenFilepath, "__proto__") && !Object.prototype.hasOwnProperty.call(exports, "__proto__") && Object.defineProperty(exports, "__proto__", {
+    enumerable: true,
+    value: getSSOTokenFilepath["__proto__"]
+  });
+  Object.keys(getSSOTokenFilepath).forEach(function(k) {
+    if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k))
+      exports[k] = getSSOTokenFilepath[k];
+  });
+});
+
+export { require_dist_cjs2 as require_dist_cjs };

package/dist/chunk-n34z5cw8.js

@@ -0,0 +1,74 @@
+// @bun
+import {
+  ReadBuffer,
+  init_stdio,
+  serializeMessage
+} from "./chunk-kraf793v.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+import process from "process";
+
+class StdioServerTransport {
+  constructor(_stdin = process.stdin, _stdout = process.stdout) {
+    this._stdin = _stdin;
+    this._stdout = _stdout;
+    this._readBuffer = new ReadBuffer;
+    this._started = false;
+    this._ondata = (chunk) => {
+      this._readBuffer.append(chunk);
+      this.processReadBuffer();
+    };
+    this._onerror = (error) => {
+      this.onerror?.(error);
+    };
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+    }
+    this._started = true;
+    this._stdin.on("data", this._ondata);
+    this._stdin.on("error", this._onerror);
+  }
+  processReadBuffer() {
+    while (true) {
+      try {
+        const message = this._readBuffer.readMessage();
+        if (message === null) {
+          break;
+        }
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onerror?.(error);
+      }
+    }
+  }
+  async close() {
+    this._stdin.off("data", this._ondata);
+    this._stdin.off("error", this._onerror);
+    const remainingDataListeners = this._stdin.listenerCount("data");
+    if (remainingDataListeners === 0) {
+      this._stdin.pause();
+    }
+    this._readBuffer.clear();
+    this.onclose?.();
+  }
+  send(message) {
+    return new Promise((resolve) => {
+      const json = serializeMessage(message);
+      if (this._stdout.write(json)) {
+        resolve();
+      } else {
+        this._stdout.once("drain", resolve);
+      }
+    });
+  }
+}
+var init_stdio2 = __esm(() => {
+  init_stdio();
+});
+
+export { StdioServerTransport, init_stdio2 as init_stdio };

package/dist/chunk-n55ehz77.js

@@ -0,0 +1,120 @@
+// @bun
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  init_file,
+  pathExists,
+  saveGlobalConfig
+} from "./chunk-7b6bg1r4.js";
+import {
+  detectCurrentRepository,
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-h1mr3371.js";
+import {
+  findGitRoot,
+  getRemoteUrlForDir,
+  init_git,
+  init_gitFilesystem
+} from "./chunk-36b2q5fg.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-404qm8xt.js";
+import {
+  getOriginalCwd,
+  init_state
+} from "./chunk-h4b85amj.js";
+
+// src/utils/githubRepoPathMapping.ts
+init_state();
+init_config();
+init_debug();
+init_detectRepository();
+init_file();
+init_gitFilesystem();
+init_git();
+import { realpath } from "fs/promises";
+async function updateGithubRepoPathMapping() {
+  try {
+    const repo = await detectCurrentRepository();
+    if (!repo) {
+      logForDebugging("Not in a GitHub repository, skipping path mapping update");
+      return;
+    }
+    const cwd = getOriginalCwd();
+    const gitRoot = findGitRoot(cwd);
+    const basePath = gitRoot ?? cwd;
+    let currentPath;
+    try {
+      currentPath = (await realpath(basePath)).normalize("NFC");
+    } catch {
+      currentPath = basePath;
+    }
+    const repoKey = repo.toLowerCase();
+    const config = getGlobalConfig();
+    const existingPaths = config.githubRepoPaths?.[repoKey] ?? [];
+    if (existingPaths[0] === currentPath) {
+      logForDebugging(`Path ${currentPath} already tracked for repo ${repoKey}`);
+      return;
+    }
+    const withoutCurrent = existingPaths.filter((p) => p !== currentPath);
+    const updatedPaths = [currentPath, ...withoutCurrent];
+    saveGlobalConfig((current) => ({
+      ...current,
+      githubRepoPaths: {
+        ...current.githubRepoPaths,
+        [repoKey]: updatedPaths
+      }
+    }));
+    logForDebugging(`Added ${currentPath} to tracked paths for repo ${repoKey}`);
+  } catch (error) {
+    logForDebugging(`Error updating repo path mapping: ${error}`);
+  }
+}
+function getKnownPathsForRepo(repo) {
+  const config = getGlobalConfig();
+  const repoKey = repo.toLowerCase();
+  return config.githubRepoPaths?.[repoKey] ?? [];
+}
+async function filterExistingPaths(paths) {
+  const results = await Promise.all(paths.map(pathExists));
+  return paths.filter((_, i) => results[i]);
+}
+async function validateRepoAtPath(path, expectedRepo) {
+  try {
+    const remoteUrl = await getRemoteUrlForDir(path);
+    if (!remoteUrl) {
+      return false;
+    }
+    const actualRepo = parseGitHubRepository(remoteUrl);
+    if (!actualRepo) {
+      return false;
+    }
+    return actualRepo.toLowerCase() === expectedRepo.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function removePathFromRepo(repo, pathToRemove) {
+  const config = getGlobalConfig();
+  const repoKey = repo.toLowerCase();
+  const existingPaths = config.githubRepoPaths?.[repoKey] ?? [];
+  const updatedPaths = existingPaths.filter((path) => path !== pathToRemove);
+  if (updatedPaths.length === existingPaths.length) {
+    return;
+  }
+  const updatedMapping = { ...config.githubRepoPaths };
+  if (updatedPaths.length === 0) {
+    delete updatedMapping[repoKey];
+  } else {
+    updatedMapping[repoKey] = updatedPaths;
+  }
+  saveGlobalConfig((current) => ({
+    ...current,
+    githubRepoPaths: updatedMapping
+  }));
+  logForDebugging(`Removed ${pathToRemove} from tracked paths for repo ${repoKey}`);
+}
+
+export { updateGithubRepoPathMapping, getKnownPathsForRepo, filterExistingPaths, validateRepoAtPath, removePathFromRepo };