thincoder 0.8.10 → 0.8.12

package/src/tui/cmd-think.mjs

@@ -4,20 +4,26 @@
 export async function handleThinkCommand(ctx) {
   const { agent, openPicker, syncProviderField } = ctx
   const cur = agent.provider
-  const thinkingEnabled = cur.thinking?.type === "enabled" || cur.thinking?.type === undefined
   const { specForModel } = await import("../config.mjs")
   const spec = specForModel(cur.model)
   const isEffortOnly = spec.thinkApi === "effort"
+  const thinkOnValue = spec.thinkOnValue ?? "enabled"
+  const isCustomThink = thinkOnValue !== "enabled"
+  // "enabled" when thinking.type matches the model's enabled value, or when thinking is absent and the model is NOT a custom-think model (defaults to on for standard models)
+  const thinkingEnabled = cur.thinking?.type === thinkOnValue || (cur.thinking?.type === undefined && !isCustomThink)
   const entries = []
+  // Auto-think: classify difficulty per-prompt and auto-set reasoning effort
+  const autoThinkEnabled = agent.config?.agent?.autoThink === true
+  entries.push({ type: "item", text: `Auto: ${autoThinkEnabled ? "ON" : "OFF"}`, action: "auto" })
   if (!isEffortOnly) {
-    entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
+    if (!autoThinkEnabled) entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
   }
-  if (spec.reasoningEffortEnum) {
+  if (spec.reasoningEffortEnum && !autoThinkEnabled) {
     for (const level of spec.reasoningEffortEnum) {
       const mark = cur.reasoningEffort === level ? "▸ " : "  "
       entries.push({ type: "item", text: `${mark}effort: ${level}`, action: "effort", level })
     }
-  } else {
+  } else if (!autoThinkEnabled) {
     entries.push({ type: "item", text: "effort: high", action: "effort", level: "high" })
     entries.push({ type: "item", text: "effort: max", action: "effort", level: "max" })
   }
@@ -25,7 +31,19 @@ export async function handleThinkCommand(ctx) {
     title: "Think",
     entries,
     onSelect: async (e) => {
-      if (e.action === "effort") {
+      if (e.action === "auto") {
+        const cfg = agent.config.agent ??= {}
+        cfg.autoThink = !cfg.autoThink
+        agent._pendingReminders = agent._pendingReminders ?? []
+        if (cfg.autoThink) {
+          // Turn off manual effort — auto will set it per-turn
+          delete cur.reasoningEffort
+          await syncProviderField("reasoningEffort", undefined)
+          agent._pendingReminders.push("[System reminder: Auto-think is now ON. Reasoning effort will be automatically set per-task based on difficulty classification.]")
+        } else {
+          agent._pendingReminders.push("[System reminder: Auto-think is now OFF. Reasoning effort will remain at its current manual setting.]")
+        }
+      } else if (e.action === "effort") {
         cur.reasoningEffort = e.level
         await syncProviderField("reasoningEffort", e.level)
       } else {
@@ -36,12 +54,20 @@ export async function handleThinkCommand(ctx) {
           if (!enable) await syncProviderField("reasoningEffort", undefined)
           else await syncProviderField("reasoningEffort", cur.reasoningEffort)
         } else {
-          cur.thinking = enable ? { type: "enabled" } : { type: "disabled" }
-          if (!enable) delete cur.reasoningEffort
-          else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+          if (enable) {
+            cur.thinking = { type: thinkOnValue }
+            if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+          } else {
+            // Custom-think models (MiniMax "adaptive") don't support "disabled" — remove the field instead
+            cur.thinking = isCustomThink ? undefined : { type: "disabled" }
+            delete cur.reasoningEffort
+          }
           await syncProviderField("thinking", cur.thinking)
-          if (!enable) await syncProviderField("reasoningEffort", undefined)
-          else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          if (enable) {
+            await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          } else {
+            await syncProviderField("reasoningEffort", undefined)
+          }
         }
       }
     },

package/src/tui/index.mjs

@@ -63,7 +63,7 @@ export async function startTUI(agent, opts = {}) {
     picker: null, // model picker { entries, lines, index, scroll, selectedLine }
     wizard: null, // first-launch config wizard { step, index, scroll, selectedLine, fields, error, lines }
     tasks: agent.tasks ?? [], // task list from task tool (progress shown in status bar); carried over on session restore, auto-collapsed when all done
-    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0 }, // cumulative token usage (shown in status bar)
+    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0, reasoningTokens: 0 }, // cumulative token usage (shown in status bar)
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
@@ -74,6 +74,7 @@ export async function startTUI(agent, opts = {}) {
     processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
     queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
+    interruptPrompt: null, // Ctrl+I interrupt message input: { text: "" } or null
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)

package/src/tui/key-handler.mjs

@@ -91,7 +91,10 @@ export function createKeyHandler(ctx) {
               insertPastedText(state, text)
               render()
             }
-          }).catch(() => { q._pasting = false })
+          }).catch((e) => {
+            q._pasting = false
+            console.error(`[tui] clipboard paste failed: ${e.message}`)
+          })
         } else if (str && !key.ctrl && !key.meta) {
           q.answer = (q.answer ?? "") + str
           render()
@@ -111,6 +114,38 @@ export function createKeyHandler(ctx) {
       setTimeout(() => process.exit(0), 100)
     }
 
+    // Ctrl+I: interrupt current generation and inject a message (time-travel inject)
+    if (key.ctrl && !key.alt && key.name === "i") {
+      if (state.processing && state.controller && !state.interruptPrompt) {
+        state.interruptPrompt = { text: "" }
+        render()
+      }
+      return
+    }
+
+    // Interrupt prompt mode: type message, Enter to inject, Esc to cancel
+    if (state.interruptPrompt) {
+      if (key.name === "escape") {
+        state.interruptPrompt = null
+        render()
+      } else if (key.name === "return") {
+        const msg = (state.interruptPrompt.text ?? "").trim()
+        state.interruptPrompt = null
+        if (msg) {
+          pushLine(`  [inject] ${msg}`, C.warn)
+          state.controller.abort({ interrupt: true, message: msg })
+          render()
+        }
+      } else if (key.name === "backspace") {
+        state.interruptPrompt.text = state.interruptPrompt.text.slice(0, -1)
+        render()
+      } else if (str && !key.ctrl && !key.meta) {
+        state.interruptPrompt.text += str.replace(/[\r\n]+/g, "")
+        render()
+      }
+      return
+    }
+
     // generic list picker: ↑↓ move, Enter confirm, Esc cancel
     if (state.picker) {
       const items = state.picker?.entries.filter((e) => e.type === "item") ?? []

package/src/tui/layout.mjs

@@ -22,7 +22,9 @@ export function computeLayout(state, { cols, rows }) {
   const W = Math.max(20, cols - 1)
 
   // --- input box ---
-  const inputLayout = layoutInput(state.input, state.cursor, W - 4)
+  const inputBuf = state.interruptPrompt ? [...state.interruptPrompt.text] : state.input
+  const inputCursor = state.interruptPrompt ? inputBuf.length : state.cursor
+  const inputLayout = layoutInput(inputBuf, inputCursor, W - 4)
   let inputOffset = 0
   if (inputLayout.lines.length > MAX_INPUT_LINES) {
     inputOffset = Math.min(inputLayout.cursorLine, inputLayout.lines.length - MAX_INPUT_LINES)

package/src/tui/pickers.mjs

@@ -185,27 +185,27 @@ export function createPickers(ctx) {
     openPicker({
       title: "Add Provider",
       entries: presetEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         if (se.kind === "custom") {
           const name = await askQuestion("Enter provider name:")
-          if (!name) { openModelPicker().catch(() => {}); return }
-          if (agent.providers.some((p) => p.name === name)) { openModelPicker().catch(() => {}); return }
+          if (!name) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
+          if (agent.providers.some((p) => p.name === name)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const baseURLRaw = await askQuestion("Enter baseURL (e.g. https://api.example.com/v1):")
-          if (!baseURLRaw) { openModelPicker().catch(() => {}); return }
+          if (!baseURLRaw) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const baseURL = baseURLRaw.replace(/\/+$/, "")
-          if (!/^https?:\/\//.test(baseURL)) { openModelPicker().catch(() => {}); return }
+          if (!/^https?:\/\//.test(baseURL)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const model = await askQuestion("Enter model name:")
-          if (!model) { openModelPicker().catch(() => {}); return }
+          if (!model) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           agent.providers.push({ name, baseURL, model })
           await persistRaw((raw) => { raw.providers = agent.providers })
           const key = await askQuestion(`Enter API key for ${name} (leave empty to skip):`)
           if (key) { await setProviderKey(name, key) }
-          openModelPicker().catch(() => {})
+          openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
           return
         }
         // preset
-        if (agent.providers.some((p) => p.name === se.name)) { openModelPicker().catch(() => {}); return }
+        if (agent.providers.some((p) => p.name === se.name)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
         const preset = PRESETS[se.name]
         const providerCfg = { name: se.name, baseURL: preset.baseURL, model: preset.model }
         if (preset.thinking) providerCfg.thinking = preset.thinking
@@ -217,7 +217,7 @@ export function createPickers(ctx) {
         await persistRaw((raw) => { raw.providers = agent.providers })
         const presetKey = await askQuestion(`Enter API key for ${se.name} (leave empty to skip):`)
         if (presetKey) await setProviderKey(se.name, presetKey)
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }
@@ -225,7 +225,7 @@ export function createPickers(ctx) {
   /** Remove provider (cannot remove the currently active one) */
   async function removeProviderFlow() {
     const candidates = agent.providers.filter((p) => p.name !== agent.activeProvider)
-    if (candidates.length === 0) { openModelPicker().catch(() => {}); return }
+    if (candidates.length === 0) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
     const removeEntries = [
       { type: "header", text: "Select provider to remove (current one cannot be removed)" },
       ...candidates.map((p) => ({ type: "item", text: `${p.name} (${p.model})`, name: p.name })),
@@ -233,12 +233,12 @@ export function createPickers(ctx) {
     openPicker({
       title: "Remove Provider",
       entries: removeEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         const at = agent.providers.findIndex((p) => p.name === se.name)
         agent.providers.splice(at, 1)
         await persistRaw((raw) => { raw.providers = agent.providers })
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }
@@ -256,12 +256,12 @@ export function createPickers(ctx) {
     openPicker({
       title: "Configure API Key",
       entries: keyEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         const key = await askQuestion(`Enter API key for ${se.name}:`)
-        if (!key) { openModelPicker().catch(() => {}); return }
+        if (!key) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
         await setProviderKey(se.name, key)
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }

package/src/tui/render-frame.mjs

@@ -40,8 +40,11 @@ export function renderFrame(state, agent, opts) {
   const thinking = agent.provider.thinking
   const effort = agent.provider.reasoningEffort
   const isMultimodal = specForModel(model).multimodal
+  const spec = specForModel(model)
+  const thinkOnValue = spec.thinkOnValue ?? "enabled"
   const thinkBadge = thinking?.type === "disabled" ? "│ think: off"
-    : effort ? `│ think: ${effort}` : thinking?.type === "enabled" ? "│ think: on" : ""
+    : effort ? `│ think: ${effort}`
+    : thinking?.type === thinkOnValue ? "│ think: on" : ""
 
   const out = [ansi.home]
   let cursorRow = 0, cursorCol = 0
@@ -145,17 +148,19 @@ export function renderFrame(state, agent, opts) {
   // ---- queue preview ----
   if (panels.queue) {
     const preview = sliceByWidth(state.queue[0].text, W - 20)
-    out.push(`${C.dim}❯ Queue: ${state.queue.length} pending${state.queue.length > 1 ? ` (next: ${preview}…)` : ` (next: ${preview})`} — Ctrl+D delete${ansi.reset}${ansi.clearLine}`)
+    out.push(`${C.dim}❯ Queue: ${state.queue.length} pending${state.queue.length > 1 ? ` (next: ${preview}…)` : ` (next: ${preview})`} — Ctrl+D delete │ Ctrl+I inject${ansi.reset}${ansi.clearLine}`)
   }
 
   // ---- input box ----
   const { borderColor, title } = inputBoxStyle(state)
   let topBorder
-  if (title === " Input " || title === " Question ") {
+  if (title === " Input " || title === " Question " || title === " Inject Message ") {
     const parts = []
     if (title === " Input ") parts.push(" Ctrl+U clear ")
     if (title === " Question ") parts.push(" Enter submit ")
+    if (title === " Inject Message ") parts.push(" Enter send, Esc cancel ")
     parts.push(" Ctrl+V paste ")
+    parts.push(" Ctrl+I inject ")
     const hint = parts.join("")
     topBorder = `╭─${title}${"─".repeat(Math.max(0, W - 4 - stringWidth(title) - stringWidth(hint)))}${hint}─╮`
   } else {
@@ -173,9 +178,10 @@ export function renderFrame(state, agent, opts) {
   const statusLine = buildStatusLine(state, agent, { cols, slashCommands })
   const autoBanner = agent.autoApprove ? `${C.warn} AUTO${ansi.reset}${ansi.dim}│` : ""
   const planBanner = agent.planMode ? `${C.tool} PLAN${ansi.reset}${ansi.dim}│` : ""
-  const bannerPrefix = (agent.planMode ? " PLAN│ " : "") + (agent.autoApprove ? " AUTO│ " : "")
+  const advisorBanner = agent.config?.advisor?.enabled ? `${C.advisor} ADVISOR${ansi.reset}${ansi.dim}│` : ""
+  const bannerPrefix = (agent.planMode ? " PLAN│ " : "") + (agent.autoApprove ? " AUTO│ " : "") + (agent.config?.advisor?.enabled ? " ADVISOR│ " : "")
   const statusMax = cols - 1 - (bannerPrefix ? stringWidth(bannerPrefix) : 0)
-  out.push(`${ansi.dim}${planBanner}${autoBanner}${sliceByWidth(statusLine, Math.max(10, statusMax))}${ansi.reset}${ansi.clearLine}`)
+  out.push(`${ansi.dim}${planBanner}${autoBanner}${advisorBanner}${sliceByWidth(statusLine, Math.max(10, statusMax))}${ansi.reset}${ansi.clearLine}`)
 
   const frame = out.join("\r\n")
 
@@ -239,7 +245,10 @@ function buildConvLines(state, cols) {
 function inputBoxStyle(state) {
   let borderColor = C.tool
   let title
-  if (state.question) {
+  if (state.interruptPrompt) {
+    borderColor = C.warn
+    title = " Inject Message "
+  } else if (state.question) {
     borderColor = C.tool
     title = " Question "
   } else if (state.permission) {
@@ -308,7 +317,7 @@ function buildStatusLine(state, agent, { cols, slashCommands }) {
   const fmtK = (n) => (n >= 10000 ? `${Math.round(n / 1000)}k` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`)
   const cacheTotal = tk.cacheHit + tk.cacheMiss
   const tokenHint = tk.prompt > 0
-    ? ` │ ↑${fmtK(tk.prompt)} ↓${fmtK(tk.completion)}${cacheTotal > 0 ? ` hit${Math.round((tk.cacheHit / cacheTotal) * 100)}%` : ""}`
+    ? ` │ ↑${fmtK(tk.prompt)} ↓${fmtK(tk.completion)}${tk.reasoningTokens > 0 ? ` ✦${fmtK(tk.reasoningTokens)}` : ""}${cacheTotal > 0 ? ` hit${Math.round((tk.cacheHit / cacheTotal) * 100)}%` : ""}`
     : ""
   const elapsed = state.processing ? ` ${Math.floor((Date.now() - state.processingStarted) / 1000)}s` : ""
   const toolHint = state.currentTool ? ` ${state.currentTool}…` : ""
@@ -321,7 +330,7 @@ function buildStatusLine(state, agent, { cols, slashCommands }) {
       : ` │ context ${ctxPct}%`
     : ""
   const queueHint = state.queue.length > 0 ? ` │ queue: ${state.queue.length}` : ""
-  return ` ${statusText}${taskHint}${tokenHint}${ctxHint}${queueHint}${scrollHint} │ Enter: send${state.processing ? " (queue)" : ""} │ /: commands │ wheel/PgUp/PgDn: scroll │ Ctrl+C: exit`
+  return ` ${statusText}${taskHint}${tokenHint}${ctxHint}${queueHint}${scrollHint} │ Enter: send${state.processing ? " (queue)" : ""} │ /: commands │ wheel/PgUp/PgDn: scroll │ Ctrl+I: inject │ Ctrl+C: exit`
 }
 
 /** Summarize tool args for subagent panel display (one line, short). Pure. */

package/src/tui/slash-commands.mjs

@@ -21,6 +21,7 @@ import { handleGoalCommand } from "./cmd-goal.mjs"
 import { handleSkillsCommand } from "./cmd-skills.mjs"
 import { handleMcpCommand } from "./cmd-mcp.mjs"
 import { handleAutoCommand } from "./cmd-auto.mjs"
+import { handleAdvisorCommand } from "./cmd-advisor.mjs"
 import { handleThinkCommand } from "./cmd-think.mjs"
 import { handleModelCommand } from "./cmd-model.mjs"
 import { handleConfigCommand } from "./cmd-config.mjs"
@@ -31,6 +32,7 @@ import { handleUpgradeCommand } from "./cmd-upgrade.mjs"
 export const SLASH_COMMANDS = [
   { name: "/plan", group: "Agent", desc: "toggle plan mode (design first, then implement)" },
   { name: "/auto", group: "Agent", desc: "toggle auto-approve" },
+  { name: "/advisor", group: "Agent", desc: "toggle advisor review & select model" },
   { name: "/model", group: "Agent", desc: "select model & manage providers" },
   { name: "/goal", group: "Agent", desc: "set/view/cancel long-term goal" },
   { name: "/think", group: "Agent", desc: "thinking mode & reasoning effort" },
@@ -63,6 +65,7 @@ const HANDLERS = {
   "/skills": handleSkillsCommand,
   "/mcp": handleMcpCommand,
   "/auto": handleAutoCommand,
+  "/advisor": handleAdvisorCommand,
   "/think": handleThinkCommand,
   "/model": handleModelCommand,
   "/config": handleConfigCommand,

package/src/tools/repomap-parse.mjs

@@ -1,168 +0,0 @@
-/**
- * repomap-parse.mjs — repo dependency graph parser (zero dependencies, pure regex)
- * Gets known file list from code_chunks, parses each file's import/export relationships in real time,
- * builds forward dependency graph + reverse reference graph. Shared by repomap.mjs's buildSummary / buildOutline.
- */
-import { readFileSync, existsSync } from "node:fs"
-import { join } from "node:path"
-
-/**
- * Scan all files, build forward dependency graph + reverse reference graph.
- * Returns { deps, importers, fileCount } shared by buildOutline / buildSummary.
- */
-export function buildDepGraph(db, cwd) {
-  const allFiles = db.prepare(`SELECT DISTINCT path FROM code_chunks ORDER BY path`).all().map((r) => r.path)
-  if (allFiles.length === 0) return null
-
-  const deps = new Map()      // path → { imports: Set, exports: Set, size: number, dir: string }
-  const importers = new Map() // importee → Set<importer>
-
-  for (const rel of allFiles) {
-    const abs = join(cwd, ...rel.split("/"))
-    if (!existsSync(abs)) continue
-    const text = readFileSync(abs, "utf8")
-    const lines = text.split("\n")
-    const ext = rel.slice(rel.lastIndexOf(".")).toLowerCase()
-
-    let imports, exports
-    if (ext === ".py") {
-      const py = parsePyOutline(lines)
-      imports = py.imports
-      exports = py.symbols
-    } else {
-      imports = parseImports(lines, ext)
-      exports = parseExports(lines, ext)
-    }
-
-    // Resolve import paths to relative paths (handle ./ ../)
-    const resolved = []
-    for (let imp of imports) {
-      if (imp.startsWith("./")) imp = imp.slice(2)
-      const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : ""
-      const parts = imp.split("/")
-      if (parts[0] === "..") {
-        const up = dir.split("/").filter(Boolean)
-        let i = 0
-        while (parts[i] === ".." && up.length > 0) { up.pop(); i++ }
-        resolved.push([...up, ...parts.slice(i)].join("/"))
-      } else {
-        resolved.push(dir ? `${dir}/${imp}` : imp)
-      }
-    }
-
-    const dir = rel.includes("/") ? rel.slice(0, rel.lastIndexOf("/")) : "."
-    deps.set(rel, { imports: new Set(resolved), exports: new Set(exports), size: Math.floor(text.length / 1024), dir })
-
-    for (const r of resolved) {
-      if (!importers.has(r)) importers.set(r, new Set())
-      importers.get(r).add(rel)
-    }
-  }
-
-  return { deps, importers, fileCount: allFiles.length }
-}
-
-// ---------------------------------------------------------- internal implementation
-
-function normalizeExt(p) {
-  return p.replace(/\.(m?js|jsx|tsx?)$/i, "")
-}
-
-/** Extract JS/TS file import paths (normalize by stripping .ts/.js/.mjs suffixes) */
-function parseImports(lines, ext) {
-  const imports = []
-  const text = lines.join("\n")
-  // standard import
-  const re = /import\s+(?:{[^}]*}|\*\s+as\s+\w+|\w+\s*,?\s*(?:{[^}]*})?)\s*from\s*['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/g
-  let m
-  while ((m = re.exec(text))) {
-    const raw = m[1] || m[2]
-    if (!raw || raw.startsWith("node:") || !raw.startsWith(".")) continue
-    imports.push(normalizeExt(raw))
-  }
-  // re-export: export { x } from './module'
-  const reExportRe = /export\s*\{[^}]*\}\s*from\s*['"]([^'"]+)['"]/g
-  while ((m = reExportRe.exec(text))) {
-    const raw = m[1]
-    if (!raw || raw.startsWith("node:") || !raw.startsWith(".")) continue
-    imports.push(normalizeExt(raw))
-  }
-  return [...new Set(imports)]
-}
-
-/** Extract JS/TS file export symbols */
-function parseExports(lines, ext) {
-  const exports = []
-  const text = lines.join("\n")
-  // export function/class/const/let/var name
-  const namedRe = /export\s+(?:async\s+)?(?:function\s+(\w+)|class\s+(\w+)|(?:const|let|var)\s+(\w+))/g
-  let m
-  while ((m = namedRe.exec(text))) {
-    exports.push(m[1] || m[2] || m[3])
-  }
-  // export default function/class name / export default expression
-  const defaultRe = /export\s+default\s+(?:(?:async\s+)?(?:function\s+(\w+)|class\s+(\w+))|(\w+))/g
-  while ((m = defaultRe.exec(text))) {
-    const name = m[1] || m[2] || m[3]
-    if (name) exports.push(name)
-    else if (!exports.some((e) => e === "default")) exports.push("default")
-  }
-  // export { a, b as c } — prefer the "as" alias as the exported name
-  const braceRe = /export\s*\{([^}]+)\}/g
-  while ((m = braceRe.exec(text))) {
-    for (const name of m[1].split(",")) {
-      const parts = name.trim().split(/\s+/)
-      // "a as b" → b (exported name), "a" → a
-      const exported = parts.length >= 3 ? parts[2] : parts[0]
-      if (exported) exports.push(exported)
-    }
-  }
-  // export const { a, b } = ... (destructured export)
-  const destructRe = /export\s+(?:const|let|var)\s*\{([^}]+)\}\s*=/g
-  while ((m = destructRe.exec(text))) {
-    for (const name of m[1].split(",")) {
-      const parts = name.trim().split(/\s*:\s*/)
-      const n = parts[0].trim()
-      if (n) exports.push(n)
-    }
-  }
-  return [...new Set(exports)]
-}
-
-/** Extract Python imports and top-level def/class */
-function parsePyOutline(lines) {
-  const imports = []
-  const symbols = []
-  for (const line of lines) {
-    const fromRe = line.match(/^from\s+(\S+)\s+import\s+(.+)/)
-    if (fromRe) {
-      const rel = pyRelPath(fromRe[1])
-      if (rel) imports.push(rel)
-      continue
-    }
-    const impRe = line.match(/^import\s+(.+)/)
-    if (impRe) {
-      for (const mod of impRe[1].split(",")) {
-        const rel = pyRelPath(mod.trim().split(/\s+/)[0])
-        if (rel) imports.push(rel)
-      }
-      continue
-    }
-    const defRe = line.match(/^(?:async\s+)?(?:def|class)\s+(\w+)/)
-    if (defRe) symbols.push(defRe[1])
-  }
-  return { imports: [...new Set(imports)], symbols: [...new Set(symbols)] }
-}
-
-/**
- * Python relative import → relative file path:
- * Leading n dots mean go up n-1 levels ("." = current package), module dots become path separators.
- * Non-relative imports (not starting with .) or bare package imports ("from . import x") return null.
- */
-function pyRelPath(mod) {
-  if (!mod?.startsWith(".")) return null
-  const dots = mod.match(/^\.+/)[0].length
-  const rest = mod.slice(dots).replaceAll(".", "/")
-  if (!rest) return null
-  return normalizeExt("../".repeat(dots - 1) + rest)
-}