@within-7/minto 0.4.2 → 0.4.3

package/dist/utils/fuzzyMatcher.js

@@ -1,258 +0,0 @@
-const DEFAULT_CONFIG = {
-  weights: {
-    prefix: 0.35,
-    // Strong weight for prefix matching
-    substring: 0.2,
-    // Good for partial matches
-    abbreviation: 0.3,
-    // Key for "nde"→"node" cases
-    editDistance: 0.1,
-    // Typo tolerance
-    popularity: 0.05
-    // Slight bias for common commands
-  },
-  minScore: 10,
-  // Lower threshold for better matching
-  maxEditDistance: 2,
-  popularCommands: [
-    "node",
-    "npm",
-    "git",
-    "ls",
-    "cd",
-    "cat",
-    "grep",
-    "find",
-    "cp",
-    "mv",
-    "python",
-    "java",
-    "docker",
-    "curl",
-    "wget",
-    "vim",
-    "nano"
-  ]
-};
-class FuzzyMatcher {
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    const weightSum = Object.values(this.config.weights).reduce(
-      (a, b) => a + b,
-      0
-    );
-    if (Math.abs(weightSum - 1) > 0.01) {
-      Object.keys(this.config.weights).forEach((key) => {
-        this.config.weights[key] /= weightSum;
-      });
-    }
-  }
-  /**
-   * Calculate fuzzy match score for a candidate against a query
-   */
-  match(candidate, query) {
-    const text = candidate.toLowerCase();
-    const pattern = query.toLowerCase();
-    if (text === pattern) {
-      return { score: 1e3, algorithm: "exact", confidence: 1 };
-    }
-    if (text.startsWith(pattern)) {
-      return {
-        score: 900 + (10 - pattern.length),
-        algorithm: "prefix-exact",
-        confidence: 0.95
-      };
-    }
-    const scores = {
-      prefix: this.prefixScore(text, pattern),
-      substring: this.substringScore(text, pattern),
-      abbreviation: this.abbreviationScore(text, pattern),
-      editDistance: this.editDistanceScore(text, pattern),
-      popularity: this.popularityScore(text)
-    };
-    const rawScore = Object.entries(scores).reduce(
-      (total, [algorithm, score]) => {
-        const weight = this.config.weights[algorithm];
-        return total + score * weight;
-      },
-      0
-    );
-    const lengthPenalty = Math.max(0, text.length - 6) * 1.5;
-    const finalScore = Math.max(0, rawScore - lengthPenalty);
-    const maxAlgorithm = Object.entries(scores).reduce(
-      (max, [alg, score]) => score > max.score ? { algorithm: alg, score } : max,
-      { algorithm: "none", score: 0 }
-    );
-    const confidence = Math.min(1, finalScore / 100);
-    return {
-      score: finalScore,
-      algorithm: maxAlgorithm.algorithm,
-      confidence
-    };
-  }
-  /**
-   * Algorithm 1: Prefix Matching (like pinyin prefix)
-   * Handles cases like "nod" → "node"
-   */
-  prefixScore(text, pattern) {
-    if (!text.startsWith(pattern)) return 0;
-    const coverage = pattern.length / text.length;
-    return 100 * coverage;
-  }
-  /**
-   * Algorithm 2: Substring Matching (like pinyin contains)
-   * Handles cases like "ode" → "node", "py3" → "python3"
-   */
-  substringScore(text, pattern) {
-    const index = text.indexOf(pattern);
-    if (index !== -1) {
-      const positionFactor = Math.max(0, 10 - index) / 10;
-      const coverageFactor = pattern.length / text.length;
-      return 80 * positionFactor * coverageFactor;
-    }
-    const numMatch = pattern.match(/^(.+?)(\d+)$/);
-    if (numMatch) {
-      const [, prefix, num] = numMatch;
-      if (text.startsWith(prefix) && text.endsWith(num)) {
-        const coverageFactor = pattern.length / text.length;
-        return 70 * coverageFactor + 20;
-      }
-    }
-    return 0;
-  }
-  /**
-   * Algorithm 3: Abbreviation Matching (key innovation)
-   * Handles cases like "nde" → "node", "pyt3" → "python3", "gp5" → "gpt-5"
-   */
-  abbreviationScore(text, pattern) {
-    let score = 0;
-    let textPos = 0;
-    let perfectStart = false;
-    let consecutiveMatches = 0;
-    let wordBoundaryMatches = 0;
-    const textWords = text.split("-");
-    const textClean = text.replace(/-/g, "").toLowerCase();
-    for (let i = 0; i < pattern.length; i++) {
-      const char = pattern[i];
-      let charFound = false;
-      for (let j = textPos; j < textClean.length; j++) {
-        if (textClean[j] === char) {
-          charFound = true;
-          let originalPos = 0;
-          let cleanPos = 0;
-          for (let k = 0; k < text.length; k++) {
-            if (text[k] === "-") continue;
-            if (cleanPos === j) {
-              originalPos = k;
-              break;
-            }
-            cleanPos++;
-          }
-          if (j === textPos) {
-            consecutiveMatches++;
-          } else {
-            consecutiveMatches = 1;
-          }
-          if (i === 0 && j === 0) {
-            score += 50;
-            perfectStart = true;
-          } else if (originalPos === 0 || text[originalPos - 1] === "-") {
-            score += 35;
-            wordBoundaryMatches++;
-          } else if (j <= 2) {
-            score += 20;
-          } else if (j <= 6) {
-            score += 10;
-          } else {
-            score += 5;
-          }
-          if (consecutiveMatches > 1) {
-            score += consecutiveMatches * 5;
-          }
-          textPos = j + 1;
-          break;
-        }
-      }
-      if (!charFound) return 0;
-    }
-    if (perfectStart) score += 30;
-    if (wordBoundaryMatches >= 2) score += 25;
-    if (textPos <= textClean.length * 0.8) score += 15;
-    const lastPatternChar = pattern[pattern.length - 1];
-    const lastTextChar = text[text.length - 1];
-    if (/\d/.test(lastPatternChar) && lastPatternChar === lastTextChar) {
-      score += 25;
-    }
-    return score;
-  }
-  /**
-   * Algorithm 4: Edit Distance (typo tolerance)
-   * Handles cases like "noda" → "node"
-   */
-  editDistanceScore(text, pattern) {
-    if (pattern.length > text.length + this.config.maxEditDistance) return 0;
-    const dp = [];
-    const m = pattern.length;
-    const n = text.length;
-    for (let i = 0; i <= m; i++) {
-      dp[i] = [];
-      for (let j = 0; j <= n; j++) {
-        if (i === 0) dp[i][j] = j;
-        else if (j === 0) dp[i][j] = i;
-        else {
-          const cost = pattern[i - 1] === text[j - 1] ? 0 : 1;
-          dp[i][j] = Math.min(
-            dp[i - 1][j] + 1,
-            // deletion
-            dp[i][j - 1] + 1,
-            // insertion
-            dp[i - 1][j - 1] + cost
-            // substitution
-          );
-        }
-      }
-    }
-    const distance = dp[m][n];
-    if (distance > this.config.maxEditDistance) return 0;
-    return Math.max(0, 30 - distance * 10);
-  }
-  /**
-   * Algorithm 5: Command Popularity (like frequency in input method)
-   * Boost common commands that users frequently type
-   */
-  popularityScore(text) {
-    if (this.config.popularCommands.includes(text)) {
-      return 40;
-    }
-    if (text.length <= 5) return 10;
-    return 0;
-  }
-  /**
-   * Batch match multiple candidates and return sorted results
-   */
-  matchMany(candidates, query) {
-    return candidates.map((candidate) => ({
-      candidate,
-      result: this.match(candidate, query)
-    })).filter((item) => item.result.score >= this.config.minScore).sort((a, b) => b.result.score - a.result.score);
-  }
-}
-const defaultMatcher = new FuzzyMatcher();
-function matchCommand(command, query) {
-  return defaultMatcher.match(command, query);
-}
-import { matchManyAdvanced } from "./advancedFuzzyMatcher.js";
-function matchCommands(commands, query) {
-  return matchManyAdvanced(commands, query, 5).map((item) => ({
-    command: item.candidate,
-    score: item.score
-  }));
-}
-export {
-  FuzzyMatcher,
-  defaultMatcher,
-  matchCommand,
-  matchCommands
-};
-//# sourceMappingURL=fuzzyMatcher.js.map

package/dist/utils/fuzzyMatcher.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/fuzzyMatcher.ts"],
-  "sourcesContent": ["/**\n * Input Method Inspired Fuzzy Matching Algorithm\n *\n * Multi-algorithm weighted scoring system inspired by:\n * - Sogou/Baidu Pinyin input method algorithms\n * - Double-pinyin abbreviation matching\n * - Terminal completion best practices (fzf, zsh, fish)\n *\n * Designed specifically for command/terminal completion scenarios\n * where users type abbreviations like \"nde\" expecting \"node\"\n */\n\nexport interface MatchResult {\n  score: number\n  algorithm: string // Which algorithm contributed most to the score\n  confidence: number // 0-1 confidence level\n}\n\nexport interface FuzzyMatcherConfig {\n  // Algorithm weights (must sum to 1.0)\n  weights: {\n    prefix: number // Direct prefix matching (\"nod\" \u2192 \"node\")\n    substring: number // Substring matching (\"ode\" \u2192 \"node\")\n    abbreviation: number // Key chars matching (\"nde\" \u2192 \"node\")\n    editDistance: number // Typo tolerance (\"noda\" \u2192 \"node\")\n    popularity: number // Common command boost\n  }\n\n  // Scoring parameters\n  minScore: number // Minimum score threshold\n  maxEditDistance: number // Maximum edits allowed\n  popularCommands: string[] // Commands to boost\n}\n\nconst DEFAULT_CONFIG: FuzzyMatcherConfig = {\n  weights: {\n    prefix: 0.35, // Strong weight for prefix matching\n    substring: 0.2, // Good for partial matches\n    abbreviation: 0.3, // Key for \"nde\"\u2192\"node\" cases\n    editDistance: 0.1, // Typo tolerance\n    popularity: 0.05, // Slight bias for common commands\n  },\n  minScore: 10, // Lower threshold for better matching\n  maxEditDistance: 2,\n  popularCommands: [\n    'node',\n    'npm',\n    'git',\n    'ls',\n    'cd',\n    'cat',\n    'grep',\n    'find',\n    'cp',\n    'mv',\n    'python',\n    'java',\n    'docker',\n    'curl',\n    'wget',\n    'vim',\n    'nano',\n  ],\n}\n\nexport class FuzzyMatcher {\n  private config: FuzzyMatcherConfig\n\n  constructor(config: Partial<FuzzyMatcherConfig> = {}) {\n    this.config = { ...DEFAULT_CONFIG, ...config }\n\n    // Normalize weights to sum to 1.0\n    const weightSum = Object.values(this.config.weights).reduce(\n      (a, b) => a + b,\n      0,\n    )\n    if (Math.abs(weightSum - 1.0) > 0.01) {\n      Object.keys(this.config.weights).forEach(key => {\n        this.config.weights[key as keyof typeof this.config.weights] /=\n          weightSum\n      })\n    }\n  }\n\n  /**\n   * Calculate fuzzy match score for a candidate against a query\n   */\n  match(candidate: string, query: string): MatchResult {\n    const text = candidate.toLowerCase()\n    const pattern = query.toLowerCase()\n\n    // Quick perfect match exits\n    if (text === pattern) {\n      return { score: 1000, algorithm: 'exact', confidence: 1.0 }\n    }\n    if (text.startsWith(pattern)) {\n      return {\n        score: 900 + (10 - pattern.length),\n        algorithm: 'prefix-exact',\n        confidence: 0.95,\n      }\n    }\n\n    // Run all algorithms\n    const scores = {\n      prefix: this.prefixScore(text, pattern),\n      substring: this.substringScore(text, pattern),\n      abbreviation: this.abbreviationScore(text, pattern),\n      editDistance: this.editDistanceScore(text, pattern),\n      popularity: this.popularityScore(text),\n    }\n\n    // Weighted combination\n    const rawScore = Object.entries(scores).reduce(\n      (total, [algorithm, score]) => {\n        const weight =\n          this.config.weights[algorithm as keyof typeof this.config.weights]\n        return total + score * weight\n      },\n      0,\n    )\n\n    // Length penalty (prefer shorter commands)\n    const lengthPenalty = Math.max(0, text.length - 6) * 1.5\n    const finalScore = Math.max(0, rawScore - lengthPenalty)\n\n    // Determine primary algorithm and confidence\n    const maxAlgorithm = Object.entries(scores).reduce(\n      (max, [alg, score]) =>\n        score > max.score ? { algorithm: alg, score } : max,\n      { algorithm: 'none', score: 0 },\n    )\n\n    const confidence = Math.min(1.0, finalScore / 100)\n\n    return {\n      score: finalScore,\n      algorithm: maxAlgorithm.algorithm,\n      confidence,\n    }\n  }\n\n  /**\n   * Algorithm 1: Prefix Matching (like pinyin prefix)\n   * Handles cases like \"nod\" \u2192 \"node\"\n   */\n  private prefixScore(text: string, pattern: string): number {\n    if (!text.startsWith(pattern)) return 0\n\n    // Score based on prefix length vs total length\n    const coverage = pattern.length / text.length\n    return 100 * coverage\n  }\n\n  /**\n   * Algorithm 2: Substring Matching (like pinyin contains)\n   * Handles cases like \"ode\" \u2192 \"node\", \"py3\" \u2192 \"python3\"\n   */\n  private substringScore(text: string, pattern: string): number {\n    // Direct substring match\n    const index = text.indexOf(pattern)\n    if (index !== -1) {\n      // Earlier position and better coverage = higher score\n      const positionFactor = Math.max(0, 10 - index) / 10\n      const coverageFactor = pattern.length / text.length\n      return 80 * positionFactor * coverageFactor\n    }\n\n    // Special handling for numeric suffixes (py3 \u2192 python3)\n    // Check if pattern ends with a number and try prefix match + number\n    const numMatch = pattern.match(/^(.+?)(\\d+)$/)\n    if (numMatch) {\n      const [, prefix, num] = numMatch\n      // Check if text starts with prefix and ends with the same number\n      if (text.startsWith(prefix) && text.endsWith(num)) {\n        // Good match for patterns like \"py3\" \u2192 \"python3\"\n        const coverageFactor = pattern.length / text.length\n        return 70 * coverageFactor + 20 // Bonus for numeric suffix match\n      }\n    }\n\n    return 0\n  }\n\n  /**\n   * Algorithm 3: Abbreviation Matching (key innovation)\n   * Handles cases like \"nde\" \u2192 \"node\", \"pyt3\" \u2192 \"python3\", \"gp5\" \u2192 \"gpt-5\"\n   */\n  private abbreviationScore(text: string, pattern: string): number {\n    let score = 0\n    let textPos = 0\n    let perfectStart = false\n    let consecutiveMatches = 0\n    let wordBoundaryMatches = 0\n\n    // Split text by hyphens to handle word boundaries better\n    const textWords = text.split('-')\n    const textClean = text.replace(/-/g, '').toLowerCase()\n\n    for (let i = 0; i < pattern.length; i++) {\n      const char = pattern[i]\n      let charFound = false\n\n      // Try to find in clean text (no hyphens)\n      for (let j = textPos; j < textClean.length; j++) {\n        if (textClean[j] === char) {\n          charFound = true\n\n          // Check if this character is at a word boundary in original text\n          let originalPos = 0\n          let cleanPos = 0\n          for (let k = 0; k < text.length; k++) {\n            if (text[k] === '-') continue\n            if (cleanPos === j) {\n              originalPos = k\n              break\n            }\n            cleanPos++\n          }\n\n          // Consecutive character bonus\n          if (j === textPos) {\n            consecutiveMatches++\n          } else {\n            consecutiveMatches = 1\n          }\n\n          // Position-sensitive scoring\n          if (i === 0 && j === 0) {\n            score += 50 // Perfect first character\n            perfectStart = true\n          } else if (originalPos === 0 || text[originalPos - 1] === '-') {\n            score += 35 // Word boundary match\n            wordBoundaryMatches++\n          } else if (j <= 2) {\n            score += 20 // Early position\n          } else if (j <= 6) {\n            score += 10 // Mid position\n          } else {\n            score += 5 // Late position\n          }\n\n          // Consecutive character bonus\n          if (consecutiveMatches > 1) {\n            score += consecutiveMatches * 5\n          }\n\n          textPos = j + 1\n          break\n        }\n      }\n\n      if (!charFound) return 0 // Invalid abbreviation\n    }\n\n    // Critical bonuses\n    if (perfectStart) score += 30\n    if (wordBoundaryMatches >= 2) score += 25 // Multiple word boundaries\n    if (textPos <= textClean.length * 0.8) score += 15 // Compact abbreviation\n\n    // Special bonus for number matching at end\n    const lastPatternChar = pattern[pattern.length - 1]\n    const lastTextChar = text[text.length - 1]\n    if (/\\d/.test(lastPatternChar) && lastPatternChar === lastTextChar) {\n      score += 25\n    }\n\n    return score\n  }\n\n  /**\n   * Algorithm 4: Edit Distance (typo tolerance)\n   * Handles cases like \"noda\" \u2192 \"node\"\n   */\n  private editDistanceScore(text: string, pattern: string): number {\n    if (pattern.length > text.length + this.config.maxEditDistance) return 0\n\n    // Simplified Levenshtein distance\n    const dp: number[][] = []\n    const m = pattern.length\n    const n = text.length\n\n    // Initialize DP table\n    for (let i = 0; i <= m; i++) {\n      dp[i] = []\n      for (let j = 0; j <= n; j++) {\n        if (i === 0) dp[i][j] = j\n        else if (j === 0) dp[i][j] = i\n        else {\n          const cost = pattern[i - 1] === text[j - 1] ? 0 : 1\n          dp[i][j] = Math.min(\n            dp[i - 1][j] + 1, // deletion\n            dp[i][j - 1] + 1, // insertion\n            dp[i - 1][j - 1] + cost, // substitution\n          )\n        }\n      }\n    }\n\n    const distance = dp[m][n]\n    if (distance > this.config.maxEditDistance) return 0\n\n    return Math.max(0, 30 - distance * 10)\n  }\n\n  /**\n   * Algorithm 5: Command Popularity (like frequency in input method)\n   * Boost common commands that users frequently type\n   */\n  private popularityScore(text: string): number {\n    if (this.config.popularCommands.includes(text)) {\n      return 40\n    }\n\n    // Short commands are often more commonly used\n    if (text.length <= 5) return 10\n\n    return 0\n  }\n\n  /**\n   * Batch match multiple candidates and return sorted results\n   */\n  matchMany(\n    candidates: string[],\n    query: string,\n  ): Array<{ candidate: string; result: MatchResult }> {\n    return candidates\n      .map(candidate => ({\n        candidate,\n        result: this.match(candidate, query),\n      }))\n      .filter(item => item.result.score >= this.config.minScore)\n      .sort((a, b) => b.result.score - a.result.score)\n  }\n}\n\n// Export convenience functions\nexport const defaultMatcher = new FuzzyMatcher()\n\nexport function matchCommand(command: string, query: string): MatchResult {\n  return defaultMatcher.match(command, query)\n}\n\n// Import the advanced matcher\nimport { matchManyAdvanced } from './advancedFuzzyMatcher'\n\nexport function matchCommands(\n  commands: string[],\n  query: string,\n): Array<{ command: string; score: number }> {\n  // Use the advanced matcher for better results\n  return matchManyAdvanced(commands, query, 5) // Lower threshold for better matching\n    .map(item => ({\n      command: item.candidate,\n      score: item.score,\n    }))\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/generators.js

@@ -1,116 +0,0 @@
-import { debug } from "./debugLogger.js";
-const NO_VALUE = Symbol("NO_VALUE");
-async function lastX(as) {
-  let lastValue = NO_VALUE;
-  for await (const a of as) {
-    lastValue = a;
-  }
-  if (lastValue === NO_VALUE) {
-    throw new Error("No items in generator");
-  }
-  return lastValue;
-}
-async function* all(generators, concurrencyCap = Infinity, abortSignal) {
-  let generatorIdCounter = 0;
-  const generatorIds = /* @__PURE__ */ new Map();
-  const activeGenerators = /* @__PURE__ */ new Set();
-  const next = (generator) => {
-    let id = generatorIds.get(generator);
-    if (id === void 0) {
-      id = generatorIdCounter++;
-      generatorIds.set(generator, id);
-    }
-    activeGenerators.add(generator);
-    const promise = generator.next().then(({ done, value }) => ({
-      done,
-      value,
-      generator,
-      promise,
-      id
-    }));
-    return promise;
-  };
-  const terminateAll = async () => {
-    debug.flow("ALL_GENERATORS_ABORT", {
-      activeCount: activeGenerators.size
-    });
-    for (const gen of activeGenerators) {
-      try {
-        await gen.return(void 0);
-      } catch {
-      }
-    }
-    activeGenerators.clear();
-  };
-  const waiting = [...generators];
-  const promises = /* @__PURE__ */ new Set();
-  debug.flow("ALL_GENERATORS_START", {
-    totalGenerators: generators.length,
-    concurrencyCap,
-    hasAbortSignal: !!abortSignal
-  });
-  if (abortSignal?.aborted) {
-    debug.flow("ALL_GENERATORS_ALREADY_ABORTED", {});
-    return;
-  }
-  while (promises.size < concurrencyCap && waiting.length > 0) {
-    const gen = waiting.shift();
-    promises.add(next(gen));
-  }
-  debug.flow("ALL_GENERATORS_INITIAL_BATCH", {
-    activeCount: promises.size,
-    waitingCount: waiting.length
-  });
-  let yieldCount = 0;
-  let completedCount = 0;
-  while (promises.size > 0) {
-    if (abortSignal?.aborted) {
-      debug.flow("ALL_GENERATORS_ABORT_DETECTED", {
-        completedCount,
-        remainingActive: promises.size
-      });
-      await terminateAll();
-      return;
-    }
-    const { done, value, generator, promise, id } = await Promise.race(promises);
-    promises.delete(promise);
-    if (abortSignal?.aborted) {
-      debug.flow("ALL_GENERATORS_ABORT_AFTER_RACE", {
-        completedCount,
-        remainingActive: promises.size
-      });
-      await terminateAll();
-      return;
-    }
-    if (!done) {
-      promises.add(next(generator));
-      if (value !== void 0) {
-        yieldCount++;
-        yield value;
-      }
-    } else {
-      completedCount++;
-      activeGenerators.delete(generator);
-      debug.flow("ALL_GENERATOR_COMPLETED", {
-        generatorId: id,
-        completedCount,
-        remainingActive: promises.size,
-        waitingCount: waiting.length
-      });
-      if (waiting.length > 0) {
-        const nextGen = waiting.shift();
-        promises.add(next(nextGen));
-      }
-    }
-  }
-  debug.flow("ALL_GENERATORS_DONE", {
-    totalGenerators: generators.length,
-    totalYields: yieldCount,
-    totalCompleted: completedCount
-  });
-}
-export {
-  all,
-  lastX
-};
-//# sourceMappingURL=generators.js.map

package/dist/utils/generators.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/generators.ts"],
-  "sourcesContent": ["import { debug } from './debugLogger'\n\nconst NO_VALUE = Symbol('NO_VALUE')\n\nexport async function lastX<A>(as: AsyncGenerator<A>): Promise<A> {\n  let lastValue: A | typeof NO_VALUE = NO_VALUE\n  for await (const a of as) {\n    lastValue = a\n  }\n  if (lastValue === NO_VALUE) {\n    throw new Error('No items in generator')\n  }\n  return lastValue\n}\n\ntype QueuedGenerator<A> = {\n  done: boolean | void\n  value: A | void\n  generator: AsyncGenerator<A, void>\n  promise: Promise<QueuedGenerator<A>>\n  id: number // Track generator ID for debugging\n}\n\n// Run all generators concurrently up to a concurrency cap, yielding values as they come in\n// Supports abort signal for graceful cancellation of all running generators\nexport async function* all<A>(\n  generators: AsyncGenerator<A, void>[],\n  concurrencyCap = Infinity,\n  abortSignal?: AbortSignal,\n): AsyncGenerator<A, void> {\n  let generatorIdCounter = 0\n  const generatorIds = new Map<AsyncGenerator<A, void>, number>()\n  const activeGenerators = new Set<AsyncGenerator<A, void>>()\n\n  const next = (generator: AsyncGenerator<A, void>) => {\n    let id = generatorIds.get(generator)\n    if (id === undefined) {\n      id = generatorIdCounter++\n      generatorIds.set(generator, id)\n    }\n    activeGenerators.add(generator)\n    const promise: Promise<QueuedGenerator<A>> = generator\n      .next()\n      .then(({ done, value }) => ({\n        done,\n        value,\n        generator,\n        promise,\n        id: id!,\n      }))\n    return promise\n  }\n\n  // Helper to gracefully terminate all active generators\n  const terminateAll = async () => {\n    debug.flow('ALL_GENERATORS_ABORT', {\n      activeCount: activeGenerators.size,\n    })\n    for (const gen of activeGenerators) {\n      try {\n        await gen.return(undefined)\n      } catch {\n        // Ignore errors during cleanup\n      }\n    }\n    activeGenerators.clear()\n  }\n\n  const waiting = [...generators]\n  const promises = new Set<Promise<QueuedGenerator<A>>>()\n\n  debug.flow('ALL_GENERATORS_START', {\n    totalGenerators: generators.length,\n    concurrencyCap,\n    hasAbortSignal: !!abortSignal,\n  })\n\n  // Check if already aborted\n  if (abortSignal?.aborted) {\n    debug.flow('ALL_GENERATORS_ALREADY_ABORTED', {})\n    return\n  }\n\n  // Start initial batch up to concurrency cap\n  while (promises.size < concurrencyCap && waiting.length > 0) {\n    const gen = waiting.shift()!\n    promises.add(next(gen))\n  }\n\n  debug.flow('ALL_GENERATORS_INITIAL_BATCH', {\n    activeCount: promises.size,\n    waitingCount: waiting.length,\n  })\n\n  let yieldCount = 0\n  let completedCount = 0\n\n  while (promises.size > 0) {\n    // Check for abort signal before each iteration\n    if (abortSignal?.aborted) {\n      debug.flow('ALL_GENERATORS_ABORT_DETECTED', {\n        completedCount,\n        remainingActive: promises.size,\n      })\n      await terminateAll()\n      return\n    }\n\n    const { done, value, generator, promise, id } = await Promise.race(promises)\n    promises.delete(promise)\n\n    // Check abort again after awaiting\n    if (abortSignal?.aborted) {\n      debug.flow('ALL_GENERATORS_ABORT_AFTER_RACE', {\n        completedCount,\n        remainingActive: promises.size,\n      })\n      await terminateAll()\n      return\n    }\n\n    if (!done) {\n      promises.add(next(generator))\n      // Yield non-undefined values from the generator\n      if (value !== undefined) {\n        yieldCount++\n        yield value as A\n      }\n    } else {\n      completedCount++\n      activeGenerators.delete(generator)\n      debug.flow('ALL_GENERATOR_COMPLETED', {\n        generatorId: id,\n        completedCount,\n        remainingActive: promises.size,\n        waitingCount: waiting.length,\n      })\n      if (waiting.length > 0) {\n        // Start a new generator when one finishes\n        const nextGen = waiting.shift()!\n        promises.add(next(nextGen))\n      }\n    }\n  }\n\n  debug.flow('ALL_GENERATORS_DONE', {\n    totalGenerators: generators.length,\n    totalYields: yieldCount,\n    totalCompleted: completedCount,\n  })\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/utils/git.js

@@ -1,83 +0,0 @@
-import { memoize } from "lodash-es";
-import { execFileNoThrow } from "./execFileNoThrow.js";
-const getIsGit = memoize(async () => {
-  const { code } = await execFileNoThrow("git", [
-    "rev-parse",
-    "--is-inside-work-tree"
-  ]);
-  return code === 0;
-});
-const getHead = async () => {
-  const { stdout } = await execFileNoThrow("git", ["rev-parse", "HEAD"]);
-  return stdout.trim();
-};
-const getBranch = async () => {
-  const { stdout } = await execFileNoThrow(
-    "git",
-    ["rev-parse", "--abbrev-ref", "HEAD"],
-    void 0,
-    void 0,
-    false
-  );
-  return stdout.trim();
-};
-const getRemoteUrl = async () => {
-  const { stdout, code } = await execFileNoThrow(
-    "git",
-    ["remote", "get-url", "origin"],
-    void 0,
-    void 0,
-    false
-  );
-  return code === 0 ? stdout.trim() : null;
-};
-const getIsHeadOnRemote = async () => {
-  const { code } = await execFileNoThrow(
-    "git",
-    ["rev-parse", "@{u}"],
-    void 0,
-    void 0,
-    false
-  );
-  return code === 0;
-};
-const getIsClean = async () => {
-  const { stdout } = await execFileNoThrow(
-    "git",
-    ["status", "--porcelain"],
-    void 0,
-    void 0,
-    false
-  );
-  return stdout.trim().length === 0;
-};
-async function getGitState() {
-  try {
-    const [commitHash, branchName, remoteUrl, isHeadOnRemote, isClean] = await Promise.all([
-      getHead(),
-      getBranch(),
-      getRemoteUrl(),
-      getIsHeadOnRemote(),
-      getIsClean()
-    ]);
-    return {
-      commitHash,
-      branchName,
-      remoteUrl,
-      isHeadOnRemote,
-      isClean
-    };
-  } catch (_) {
-    return null;
-  }
-}
-export {
-  getBranch,
-  getGitState,
-  getHead,
-  getIsClean,
-  getIsGit,
-  getIsHeadOnRemote,
-  getRemoteUrl
-};
-//# sourceMappingURL=git.js.map

package/dist/utils/git.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/git.ts"],
-  "sourcesContent": ["import { memoize } from 'lodash-es'\nimport { execFileNoThrow } from './execFileNoThrow'\n\nexport const getIsGit = memoize(async (): Promise<boolean> => {\n  const { code } = await execFileNoThrow('git', [\n    'rev-parse',\n    '--is-inside-work-tree',\n  ])\n  return code === 0\n})\n\nexport const getHead = async (): Promise<string> => {\n  const { stdout } = await execFileNoThrow('git', ['rev-parse', 'HEAD'])\n  return stdout.trim()\n}\n\nexport const getBranch = async (): Promise<string> => {\n  const { stdout } = await execFileNoThrow(\n    'git',\n    ['rev-parse', '--abbrev-ref', 'HEAD'],\n    undefined,\n    undefined,\n    false,\n  )\n  return stdout.trim()\n}\n\nexport const getRemoteUrl = async (): Promise<string | null> => {\n  // This might fail if there is no remote called origin\n  const { stdout, code } = await execFileNoThrow(\n    'git',\n    ['remote', 'get-url', 'origin'],\n    undefined,\n    undefined,\n    false,\n  )\n  return code === 0 ? stdout.trim() : null\n}\n\nexport const getIsHeadOnRemote = async (): Promise<boolean> => {\n  const { code } = await execFileNoThrow(\n    'git',\n    ['rev-parse', '@{u}'],\n    undefined,\n    undefined,\n    false,\n  )\n  return code === 0\n}\n\nexport const getIsClean = async (): Promise<boolean> => {\n  const { stdout } = await execFileNoThrow(\n    'git',\n    ['status', '--porcelain'],\n    undefined,\n    undefined,\n    false,\n  )\n  return stdout.trim().length === 0\n}\n\nexport interface GitRepoState {\n  commitHash: string\n  branchName: string\n  remoteUrl: string | null\n  isHeadOnRemote: boolean\n  isClean: boolean\n}\n\nexport async function getGitState(): Promise<GitRepoState | null> {\n  try {\n    const [commitHash, branchName, remoteUrl, isHeadOnRemote, isClean] =\n      await Promise.all([\n        getHead(),\n        getBranch(),\n        getRemoteUrl(),\n        getIsHeadOnRemote(),\n        getIsClean(),\n      ])\n\n    return {\n      commitHash,\n      branchName,\n      remoteUrl,\n      isHeadOnRemote,\n      isClean,\n    }\n  } catch (_) {\n    // Fail silently - git state is best effort\n    return null\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,eAAe;AACxB,SAAS,uBAAuB;AAEzB,MAAM,WAAW,QAAQ,YAA8B;AAC5D,QAAM,EAAE,KAAK,IAAI,MAAM,gBAAgB,OAAO;AAAA,IAC5C;AAAA,IACA;AAAA,EACF,CAAC;AACD,SAAO,SAAS;AAClB,CAAC;AAEM,MAAM,UAAU,YAA6B;AAClD,QAAM,EAAE,OAAO,IAAI,MAAM,gBAAgB,OAAO,CAAC,aAAa,MAAM,CAAC;AACrE,SAAO,OAAO,KAAK;AACrB;AAEO,MAAM,YAAY,YAA6B;AACpD,QAAM,EAAE,OAAO,IAAI,MAAM;AAAA,IACvB;AAAA,IACA,CAAC,aAAa,gBAAgB,MAAM;AAAA,IACpC;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,SAAO,OAAO,KAAK;AACrB;AAEO,MAAM,eAAe,YAAoC;AAE9D,QAAM,EAAE,QAAQ,KAAK,IAAI,MAAM;AAAA,IAC7B;AAAA,IACA,CAAC,UAAU,WAAW,QAAQ;AAAA,IAC9B;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,SAAO,SAAS,IAAI,OAAO,KAAK,IAAI;AACtC;AAEO,MAAM,oBAAoB,YAA8B;AAC7D,QAAM,EAAE,KAAK,IAAI,MAAM;AAAA,IACrB;AAAA,IACA,CAAC,aAAa,MAAM;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,SAAO,SAAS;AAClB;AAEO,MAAM,aAAa,YAA8B;AACtD,QAAM,EAAE,OAAO,IAAI,MAAM;AAAA,IACvB;AAAA,IACA,CAAC,UAAU,aAAa;AAAA,IACxB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,SAAO,OAAO,KAAK,EAAE,WAAW;AAClC;AAUA,eAAsB,cAA4C;AAChE,MAAI;AACF,UAAM,CAAC,YAAY,YAAY,WAAW,gBAAgB,OAAO,IAC/D,MAAM,QAAQ,IAAI;AAAA,MAChB,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA,MACb,kBAAkB;AAAA,MAClB,WAAW;AAAA,IACb,CAAC;AAEH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,SAAS,GAAG;AAEV,WAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/dist/utils/globalErrorHandler.js

@@ -1,58 +0,0 @@
-import { gracefulExit } from "./exit.js";
-let isInitialized = false;
-function handleWarning(warning) {
-  if (process.env.VERBOSE === "true" || warning.name === "DeprecationWarning" || warning.name === "ExperimentalWarning") {
-    console.warn(`
-\u26A0\uFE0F  Warning [${warning.name}]: ${warning.message}`);
-  }
-}
-const cleanupHandlers = [];
-function registerCleanupHandler(handler) {
-  cleanupHandlers.push(handler);
-}
-function unregisterCleanupHandler(handler) {
-  const index = cleanupHandlers.indexOf(handler);
-  if (index > -1) {
-    cleanupHandlers.splice(index, 1);
-  }
-}
-async function runCleanupHandlers() {
-  for (const handler of cleanupHandlers) {
-    try {
-      await handler();
-    } catch (error) {
-      console.error("Cleanup handler error:", error);
-    }
-  }
-}
-function initGlobalErrorHandlers() {
-  if (isInitialized) return;
-  isInitialized = true;
-  process.on("warning", handleWarning);
-  process.on("beforeExit", (code) => {
-    if (cleanupHandlers.length > 0) {
-      gracefulExit(code);
-    }
-  });
-}
-function isGlobalErrorHandlersInitialized() {
-  return isInitialized;
-}
-function resetGlobalErrorHandlers() {
-  if (process.env.NODE_ENV !== "test") {
-    throw new Error("resetGlobalErrorHandlers can only be called in tests");
-  }
-  process.removeAllListeners("warning");
-  process.removeAllListeners("beforeExit");
-  isInitialized = false;
-  cleanupHandlers.length = 0;
-}
-export {
-  initGlobalErrorHandlers,
-  isGlobalErrorHandlersInitialized,
-  registerCleanupHandler,
-  resetGlobalErrorHandlers,
-  runCleanupHandlers,
-  unregisterCleanupHandler
-};
-//# sourceMappingURL=globalErrorHandler.js.map

package/dist/utils/globalErrorHandler.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/globalErrorHandler.ts"],
-  "sourcesContent": ["/**\n * Global Error Handler\n *\n * Handles process warnings, cleanup handler orchestration, and\n * delegates shutdown to exit.ts's gracefulExit() to avoid dual\n * shutdown paths.\n *\n * NOTE: Signal handlers (SIGINT, SIGTERM, SIGBREAK) and process lifecycle\n * handlers (exit, unhandledRejection, uncaughtException) are managed by\n * setupExitHandlers() in exit.ts to avoid duplicate registrations.\n */\n\nimport { gracefulExit } from './exit'\n\nlet isInitialized = false\n\n/**\n * Handle process warnings\n */\nfunction handleWarning(warning: Error): void {\n  // Only log in verbose mode or for specific warning types\n  if (\n    process.env.VERBOSE === 'true' ||\n    warning.name === 'DeprecationWarning' ||\n    warning.name === 'ExperimentalWarning'\n  ) {\n    console.warn(`\\n\u26A0\uFE0F  Warning [${warning.name}]: ${warning.message}`)\n  }\n}\n\n/**\n * Cleanup handlers for graceful shutdown.\n * These are run by exit.ts's gracefulExit() via runCleanupHandlers().\n */\nconst cleanupHandlers: Array<() => void | Promise<void>> = []\n\n/**\n * Register a cleanup handler to be called during shutdown\n */\nexport function registerCleanupHandler(\n  handler: () => void | Promise<void>,\n): void {\n  cleanupHandlers.push(handler)\n}\n\n/**\n * Unregister a cleanup handler\n */\nexport function unregisterCleanupHandler(\n  handler: () => void | Promise<void>,\n): void {\n  const index = cleanupHandlers.indexOf(handler)\n  if (index > -1) {\n    cleanupHandlers.splice(index, 1)\n  }\n}\n\n/**\n * Run all registered cleanup handlers.\n * Called by exit.ts's gracefulExit() to integrate cleanup into\n * the single shutdown path.\n */\nexport async function runCleanupHandlers(): Promise<void> {\n  for (const handler of cleanupHandlers) {\n    try {\n      await handler()\n    } catch (error) {\n      console.error('Cleanup handler error:', error)\n    }\n  }\n}\n\n/**\n * Initialize global error handlers\n * Should be called early in the application lifecycle.\n *\n * NOTE: Signal handlers (SIGINT, SIGTERM, SIGBREAK) and process lifecycle\n * handlers (exit, unhandledRejection, uncaughtException) are managed by\n * setupExitHandlers() in exit.ts to avoid duplicate registrations.\n * This module focuses on warning handling and cleanup handler orchestration.\n */\nexport function initGlobalErrorHandlers(): void {\n  if (isInitialized) return\n  isInitialized = true\n\n  // Handle warnings (unique to this module \u2014 exit.ts does not handle warnings)\n  process.on('warning', handleWarning)\n\n  // Handle beforeExit for cleanup \u2014 delegate to exit.ts's unified shutdown\n  process.on('beforeExit', code => {\n    if (cleanupHandlers.length > 0) {\n      gracefulExit(code)\n    }\n  })\n}\n\n/**\n * Check if global error handlers are initialized\n */\nexport function isGlobalErrorHandlersInitialized(): boolean {\n  return isInitialized\n}\n\n/**\n * Reset global error handlers (for testing)\n */\nexport function resetGlobalErrorHandlers(): void {\n  if (process.env.NODE_ENV !== 'test') {\n    throw new Error('resetGlobalErrorHandlers can only be called in tests')\n  }\n\n  process.removeAllListeners('warning')\n  process.removeAllListeners('beforeExit')\n\n  isInitialized = false\n  cleanupHandlers.length = 0\n}\n"],
-  "mappings": "AAYA,SAAS,oBAAoB;AAE7B,IAAI,gBAAgB;AAKpB,SAAS,cAAc,SAAsB;AAE3C,MACE,QAAQ,IAAI,YAAY,UACxB,QAAQ,SAAS,wBACjB,QAAQ,SAAS,uBACjB;AACA,YAAQ,KAAK;AAAA,yBAAkB,QAAQ,IAAI,MAAM,QAAQ,OAAO,EAAE;AAAA,EACpE;AACF;AAMA,MAAM,kBAAqD,CAAC;AAKrD,SAAS,uBACd,SACM;AACN,kBAAgB,KAAK,OAAO;AAC9B;AAKO,SAAS,yBACd,SACM;AACN,QAAM,QAAQ,gBAAgB,QAAQ,OAAO;AAC7C,MAAI,QAAQ,IAAI;AACd,oBAAgB,OAAO,OAAO,CAAC;AAAA,EACjC;AACF;AAOA,eAAsB,qBAAoC;AACxD,aAAW,WAAW,iBAAiB;AACrC,QAAI;AACF,YAAM,QAAQ;AAAA,IAChB,SAAS,OAAO;AACd,cAAQ,MAAM,0BAA0B,KAAK;AAAA,IAC/C;AAAA,EACF;AACF;AAWO,SAAS,0BAAgC;AAC9C,MAAI,cAAe;AACnB,kBAAgB;AAGhB,UAAQ,GAAG,WAAW,aAAa;AAGnC,UAAQ,GAAG,cAAc,UAAQ;AAC/B,QAAI,gBAAgB,SAAS,GAAG;AAC9B,mBAAa,IAAI;AAAA,IACnB;AAAA,EACF,CAAC;AACH;AAKO,SAAS,mCAA4C;AAC1D,SAAO;AACT;AAKO,SAAS,2BAAiC;AAC/C,MAAI,QAAQ,IAAI,aAAa,QAAQ;AACnC,UAAM,IAAI,MAAM,sDAAsD;AAAA,EACxE;AAEA,UAAQ,mBAAmB,SAAS;AACpC,UAAQ,mBAAmB,YAAY;AAEvC,kBAAgB;AAChB,kBAAgB,SAAS;AAC3B;",
-  "names": []
-}