@apinggithub/mydsh-auto-model-router 0.0.0-stage → 0.2.1

package/rules.mjs

@@ -0,0 +1,59 @@
+// Rule layer (tier 1): zero-cost deterministic routing.
+// Rules are tried in order; the first rule whose pattern matches the
+// classification text wins and returns a LEVEL id (L0…L3), which the router
+// maps to the user-configured model for that level.
+
+/**
+ * Match the classification text against every rule.
+ * @param {object[]} rules - normalized rules from resolveConfig.
+ * @param {string} text - the text to classify against.
+ * @returns {string | null} the first matching rule's level, or null.
+ */
+export function matchRules(rules, text) {
+  if (!rules || rules.length === 0) return null
+  const haystack = String(text ?? '')
+  if (haystack.trim() === '') return null
+  for (const rule of rules) {
+    if (rule.regex) {
+      rule.regex.lastIndex = 0
+      if (rule.regex.test(haystack)) return rule.level
+    } else if (haystack.toLowerCase().includes(rule.match.toLowerCase())) {
+      return rule.level
+    }
+  }
+  return null
+}
+
+/**
+ * Build the text the router classifies on for one step.
+ * Concatenates the latest user message content plus the session's cwd so
+ * rules can match paths ("src/api", "migrations").
+ * @param {object} options - { messages, cwd }.
+ * @returns {string} classification haystack.
+ */
+export function classificationText({ messages = [], cwd = '' } = {}) {
+  const parts = []
+  for (let i = messages.length - 1; i >= 0 && parts.length < 3; i--) {
+    const message = messages[i]
+    if (message?.role !== 'user') continue
+    const text = extractText(message)
+    if (text) {
+      parts.unshift(text)
+      break
+    }
+  }
+  if (cwd) parts.push(` cwd:${cwd}`)
+  return parts.join('\n')
+}
+
+function extractText(message) {
+  const content = message?.content
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content
+      .map((block) => (typeof block?.text === 'string' ? block.text : ''))
+      .join('\n')
+      .trim()
+  }
+  return ''
+}

package/scoring.mjs

@@ -0,0 +1,69 @@
+// Keyword scoring for fully-auto mode (MODE C).
+//
+// Each rule carries a level; every keyword HIT in the window text (本次输入 +
+// 上次输入 + 上次回复) adds the level's weight once per occurrence (counted
+// per match, so a message mentioning "refactor" three times scores 3×).
+// The accumulated score maps to a level through the configured bands.
+// A score of 0 means no rule hit → the router falls through to the LLM
+// classifier.
+
+/**
+ * Score one window text against the rules and return the level band.
+ * @param {object[]} rules - [{ match, regex, level }]
+ * @param {object} scoring - { weights, bands }
+ * @param {string} text - the scoring window text.
+ * @returns {{ level: string|null, score: number, hits: number }}
+ *   level null when the score resolves to the 0 band (caller → classifier).
+ */
+export function scoreRules(rules, scoring, text) {
+  const haystack = String(text ?? '')
+  let score = 0
+  let hits = 0
+  if (haystack.trim() !== '') {
+    for (const rule of rules) {
+      const weight = scoring.weights[rule.level] ?? 1
+      let count = 0
+      if (rule.regex) {
+        rule.regex.lastIndex = 0
+        const copy = new RegExp(rule.regex.source, rule.regex.flags.includes('g') ? rule.regex.flags : `${rule.regex.flags}g`)
+        let m
+        while ((m = copy.exec(haystack)) !== null) {
+          count++
+          if (m[0] === '') copy.lastIndex++
+        }
+      } else {
+        // Count non-overlapping substring occurrences case-insensitively.
+        const needle = rule.match.toLowerCase()
+        const lower = haystack.toLowerCase()
+        let idx = lower.indexOf(needle)
+        while (idx !== -1) {
+          count++
+          idx = lower.indexOf(needle, idx + needle.length)
+        }
+      }
+      if (count > 0) {
+        hits += count
+        score += count * weight
+      }
+    }
+  }
+  const level = bandLevel(scoring.bands, score)
+  return { level, score, hits }
+}
+
+/**
+ * Map a score to a level through the bands (first band whose maxScore
+ * contains the score wins; null maxScore is a catch-all).
+ * A score of 0 resolves to null — the router falls through to the LLM
+ * classifier instead of pinning to the lowest level directly.
+ * @param {object[]} bands - [{ maxScore, level }]
+ * @param {number} score
+ * @returns {string | null} level id, or null when score is 0.
+ */
+export function bandLevel(bands, score) {
+  if (score <= 0) return null
+  for (const band of bands) {
+    if (band.maxScore === null || score <= band.maxScore) return band.level
+  }
+  return bands[bands.length - 1]?.level ?? null
+}

package/text-width.mjs

@@ -0,0 +1,73 @@
+// Text-width counting for the heuristic lock.
+//
+// counting modes:
+//   cjk2   — CJK codepoints (>= U+3000) count 2, everything else 1.
+//            A Chinese char is ~1.5 tokens vs an ASCII char ~0.25 tokens;
+//            doubling the CJK width keeps "10 chars" intuitive for Chinese.
+//   tokens — token estimation: CJK at 1.5/char, other at 0.25/char (chars/4).
+
+const CJK_MIN = 0x3000
+
+/**
+ * Width of one string under the configured counting mode.
+ * @param {string} text
+ * @param {'cjk2'|'tokens'} [mode]
+ * @returns {number}
+ */
+export function textWidth(text, mode = 'cjk2') {
+  const s = String(text ?? '')
+  let cjk = 0
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) >= CJK_MIN) cjk++
+  }
+  const other = s.length - cjk
+  if (mode === 'tokens') {
+    return Math.ceil(cjk * 1.5 + other / 4)
+  }
+  return cjk * 2 + other
+}
+
+/**
+ * Sum the widths of the last `windowSize` texts in order.
+ * @param {string[]} texts - newest-last.
+ * @param {number} windowSize
+ * @param {'cjk2'|'tokens'} [mode]
+ * @returns {number}
+ */
+export function windowWidth(texts, windowSize, mode = 'cjk2') {
+  const tail = texts.slice(-windowSize)
+  return tail.reduce((sum, text) => sum + textWidth(text, mode), 0)
+}
+
+/**
+ * Resolve a level from the heuristic thresholds for a width.
+ * Thresholds are ordered ascending; the FIRST threshold with
+ * `width <= maxChars` wins. A threshold with `maxChars: null` is a catch-all.
+ * Widths above every finite threshold resolve to the LAST threshold's level
+ * (the top of the lock); callers that need to distinguish "above the lock"
+ * check the top finite threshold themselves.
+ * @param {object[]} thresholds - [{ maxChars, level }]
+ * @param {number} width
+ * @returns {string} LEVEL_IDS entry
+ */
+export function levelForWidth(thresholds, width) {
+  for (const t of thresholds) {
+    if (t.maxChars === null || width <= t.maxChars) return t.level
+  }
+  return thresholds[thresholds.length - 1]?.level ?? 'L1'
+}
+
+/**
+ * The top finite threshold's maxChars, or null when every threshold is
+ * unbounded. Used by the router to detect "above the heuristic lock".
+ * @param {object[]} thresholds
+ * @returns {number | null}
+ */
+export function lockCeiling(thresholds) {
+  for (let i = thresholds.length - 1; i >= 0; i--) {
+    if (thresholds[i]?.maxChars !== null && thresholds[i]?.maxChars !== undefined) {
+      return thresholds[i].maxChars
+    }
+  }
+  return null
+}