u-foo 1.9.8 → 2.2.0

package/src/config.js

@@ -7,10 +7,13 @@ const UCODE_FIELDS = ["ucodeProvider", "ucodeModel", "ucodeBaseUrl", "ucodeApiKe
 const DEFAULT_CONFIG = {
   launchMode: "auto",
   agentProvider: "codex-cli",
+  controllerMode: "legacy",
+  codexInternalThreadMode: "legacy",
+  codexAuthPath: "",
+  claudeOauthProfile: "",
+  claudeOauthTokenPath: "",
+  claudeOauthRefreshWindowSec: 300,
   agentModel: "",
-  assistantEngine: "auto",
-  assistantModel: "",
-  assistantUfooCmd: "",
   autoResume: false,
 };
 
@@ -33,17 +36,39 @@ function normalizeLaunchMode(value) {
 
 function normalizeAgentProvider(value) {
   if (value === "claude-cli") return "claude-cli";
-  if (value === "ucode" || value === "ufoo" || value === "ufoo-code") return "ucode";
   return "codex-cli";
 }
 
-function normalizeAssistantEngine(value) {
+function normalizeControllerMode(value) {
   const raw = String(value || "").trim().toLowerCase();
-  if (!raw || raw === "auto") return "auto";
-  if (raw === "codex" || raw === "codex-cli" || raw === "codex-code") return "codex";
-  if (raw === "claude" || raw === "claude-cli" || raw === "claude-code") return "claude";
-  if (raw === "ufoo") return "ufoo";
-  return "auto";
+  if (raw === "shadow") return "shadow";
+  if (raw === "router-api") return "router-api";
+  if (raw === "loop") return "loop";
+  return "legacy";
+}
+
+function normalizeCodexInternalThreadMode(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === "sdk") return "sdk";
+  return "legacy";
+}
+
+function normalizeCodexAuthPath(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeClaudeOauthProfile(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeClaudeOauthTokenPath(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeClaudeOauthRefreshWindowSec(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num < 0) return 300;
+  return Math.floor(num);
 }
 
 function globalConfigPath() {
@@ -70,9 +95,12 @@ function loadConfig(projectRoot) {
       ...raw,
       launchMode: normalizeLaunchMode(raw.launchMode),
       agentProvider: normalizeAgentProvider(raw.agentProvider),
-      assistantEngine: normalizeAssistantEngine(raw.assistantEngine),
-      assistantModel: typeof raw.assistantModel === "string" ? raw.assistantModel : "",
-      assistantUfooCmd: typeof raw.assistantUfooCmd === "string" ? raw.assistantUfooCmd : "",
+      controllerMode: normalizeControllerMode(raw.controllerMode),
+      codexInternalThreadMode: normalizeCodexInternalThreadMode(raw.codexInternalThreadMode),
+      codexAuthPath: normalizeCodexAuthPath(raw.codexAuthPath),
+      claudeOauthProfile: normalizeClaudeOauthProfile(raw.claudeOauthProfile),
+      claudeOauthTokenPath: normalizeClaudeOauthTokenPath(raw.claudeOauthTokenPath),
+      claudeOauthRefreshWindowSec: normalizeClaudeOauthRefreshWindowSec(raw.claudeOauthRefreshWindowSec),
       autoResume: raw.autoResume !== false,
       // Merge ucode fields from global config so callers still see them
       ...loadGlobalUcodeConfig(),
@@ -109,9 +137,12 @@ function saveConfig(projectRoot, config) {
   }
   merged.launchMode = normalizeLaunchMode(merged.launchMode);
   merged.agentProvider = normalizeAgentProvider(merged.agentProvider);
-  merged.assistantEngine = normalizeAssistantEngine(merged.assistantEngine);
-  merged.assistantModel = typeof merged.assistantModel === "string" ? merged.assistantModel : "";
-  merged.assistantUfooCmd = typeof merged.assistantUfooCmd === "string" ? merged.assistantUfooCmd : "";
+  merged.controllerMode = normalizeControllerMode(merged.controllerMode);
+  merged.codexInternalThreadMode = normalizeCodexInternalThreadMode(merged.codexInternalThreadMode);
+  merged.codexAuthPath = normalizeCodexAuthPath(merged.codexAuthPath);
+  merged.claudeOauthProfile = normalizeClaudeOauthProfile(merged.claudeOauthProfile);
+  merged.claudeOauthTokenPath = normalizeClaudeOauthTokenPath(merged.claudeOauthTokenPath);
+  merged.claudeOauthRefreshWindowSec = normalizeClaudeOauthRefreshWindowSec(merged.claudeOauthRefreshWindowSec);
   merged.autoResume = merged.autoResume !== false;
   fs.writeFileSync(target, JSON.stringify(merged, null, 2));
   return merged;
@@ -149,5 +180,10 @@ module.exports = {
   saveGlobalUcodeConfig,
   normalizeLaunchMode,
   normalizeAgentProvider,
-  normalizeAssistantEngine,
+  normalizeControllerMode,
+  normalizeCodexInternalThreadMode,
+  normalizeCodexAuthPath,
+  normalizeClaudeOauthProfile,
+  normalizeClaudeOauthTokenPath,
+  normalizeClaudeOauthRefreshWindowSec,
 };

package/src/controller/flags.js

@@ -0,0 +1,160 @@
+const fs = require("fs");
+const path = require("path");
+const { loadConfig, normalizeControllerMode } = require("../config");
+
+const CONTROLLER_MODES = Object.freeze({
+  LEGACY: "legacy",
+  SHADOW: "shadow",
+  ROUTER_API: "router-api",
+  LOOP: "loop",
+});
+
+const CONTROLLER_MODE_HISTORY_LIMIT = 16;
+
+const appliedControllerModes = new Map();
+const appliedControllerModeHistory = new Map();
+
+function readProcessControllerMode(env = process.env) {
+  return normalizeControllerMode(env.UFOO_CONTROLLER_MODE);
+}
+
+function resolveControllerMode({
+  projectRoot,
+  requestedMode = "",
+  env = process.env,
+  config = null,
+} = {}) {
+  const explicit = normalizeControllerMode(requestedMode);
+  if (explicit !== CONTROLLER_MODES.LEGACY || String(requestedMode || "").trim().toLowerCase() === CONTROLLER_MODES.LEGACY) {
+    return explicit;
+  }
+
+  const hasExplicitConfig = config && typeof config === "object"
+    ? Object.prototype.hasOwnProperty.call(config, "controllerMode")
+    : Boolean(projectRoot) && fs.existsSync(path.join(projectRoot, ".ufoo", "config.json"));
+  const loadedConfig = hasExplicitConfig
+    ? (config && typeof config === "object" ? config : loadConfig(projectRoot))
+    : null;
+  if (loadedConfig) {
+    const projectMode = normalizeControllerMode(loadedConfig.controllerMode);
+    return projectMode;
+  }
+
+  return readProcessControllerMode(env);
+}
+
+function getControllerModeStateKey(projectRoot = "") {
+  const text = String(projectRoot || "").trim();
+  return text || "__default__";
+}
+
+function pushModeHistory(key, previousMode, normalizedMode, messageId) {
+  if (!previousMode || previousMode === normalizedMode) return;
+  const list = appliedControllerModeHistory.get(key) || [];
+  list.push({
+    from_mode: previousMode,
+    to_mode: normalizedMode,
+    applied_from_msg_id: String(messageId || "").trim(),
+  });
+  while (list.length > CONTROLLER_MODE_HISTORY_LIMIT) list.shift();
+  appliedControllerModeHistory.set(key, list);
+}
+
+function applyControllerModeForMessage({
+  projectRoot,
+  nextMode = CONTROLLER_MODES.LEGACY,
+  messageId = "",
+} = {}) {
+  const key = getControllerModeStateKey(projectRoot);
+  const normalizedMode = normalizeControllerMode(nextMode);
+  const previousMode = appliedControllerModes.get(key) || null;
+  appliedControllerModes.set(key, normalizedMode);
+
+  if (!previousMode || previousMode === normalizedMode) {
+    return {
+      mode: normalizedMode,
+      transition: null,
+    };
+  }
+
+  pushModeHistory(key, previousMode, normalizedMode, messageId);
+
+  return {
+    mode: normalizedMode,
+    transition: {
+      from_mode: previousMode,
+      to_mode: normalizedMode,
+      applied_from_msg_id: String(messageId || "").trim(),
+    },
+  };
+}
+
+function rollbackControllerModeForMessage({
+  projectRoot,
+  messageId = "",
+} = {}) {
+  const key = getControllerModeStateKey(projectRoot);
+  const list = appliedControllerModeHistory.get(key) || [];
+  const lastTransition = list.length > 0 ? list[list.length - 1] : null;
+  const currentMode = appliedControllerModes.get(key) || CONTROLLER_MODES.LEGACY;
+
+  if (!lastTransition) {
+    return {
+      mode: currentMode,
+      transition: null,
+      rolled_back: false,
+    };
+  }
+
+  list.pop();
+  appliedControllerModeHistory.set(key, list);
+
+  const nextMode = normalizeControllerMode(lastTransition.from_mode);
+  appliedControllerModes.set(key, nextMode);
+
+  if (nextMode === currentMode) {
+    return {
+      mode: nextMode,
+      transition: null,
+      rolled_back: true,
+    };
+  }
+
+  return {
+    mode: nextMode,
+    rolled_back: true,
+    transition: {
+      from_mode: currentMode,
+      to_mode: nextMode,
+      applied_from_msg_id: String(messageId || "").trim(),
+      rolled_back: true,
+      restored_from_msg_id: String(lastTransition.applied_from_msg_id || "").trim(),
+    },
+  };
+}
+
+function getAppliedControllerMode(projectRoot) {
+  const key = getControllerModeStateKey(projectRoot);
+  return appliedControllerModes.get(key) || CONTROLLER_MODES.LEGACY;
+}
+
+function getControllerModeHistoryForTests(projectRoot) {
+  const key = getControllerModeStateKey(projectRoot);
+  return (appliedControllerModeHistory.get(key) || []).slice();
+}
+
+function resetAppliedControllerModesForTests() {
+  appliedControllerModes.clear();
+  appliedControllerModeHistory.clear();
+}
+
+module.exports = {
+  CONTROLLER_MODES,
+  applyControllerModeForMessage,
+  getAppliedControllerMode,
+  getControllerModeHistoryForTests,
+  readProcessControllerMode,
+  resetAppliedControllerModesForTests,
+  resolveControllerMode,
+  rollbackControllerModeForMessage,
+};

package/src/controller/gateRouter.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const { loadConfig } = require("../config");
+
+const DEFAULT_EXECUTION_PATH = "legacy";
+const DEFAULT_CONFIDENCE_THRESHOLD = 0.6;
+const DEFAULT_TIMEOUT_MS = 5000;
+
+const ROUTING_PATTERNS = [
+  /\bwho should\b/i,
+  /\bwhich agent\b/i,
+  /\broute (?:this|it|that|the request)\b/i,
+  /\bcontinue with\b/i,
+  /\bhand\s+off\b/i,
+  /\bsend (?:this|it|that)\b/i,
+  /\bassign (?:this|it|that)\b/i,
+  /\bforward (?:this|it|that)\b/i,
+  /\bshould (?:i|we) ask\b/i,
+  /\bnew (?:codex|claude|ucode)\b/i,
+  /交给谁/,
+  /继续给/,
+  /发送(?:这个|它|这条|这个任务)?给/,
+  /让.*(?:接这个任务|接手|处理这个|来处理)/,
+  /发给/,
+  /转给/,
+  /应该找谁/,
+  /需要新开.*(?:codex|claude|ucode)/i,
+];
+
+const NON_ROUTING_PATTERNS = [
+  /\bfix\b/i,
+  /\bimplement\b/i,
+  /\bwrite\b/i,
+  /\bedit\b/i,
+  /\brefactor\b/i,
+  /\btest\b/i,
+  /\binvestigate\b/i,
+  /\bdebug\b/i,
+  /\bbuild\b/i,
+  /\bcreate\b/i,
+  /\bsearch\b/i,
+  /\bopen\b/i,
+  /\bread\b/i,
+  /修复/,
+  /修正/,
+  /实现/,
+  /重构/,
+  /测试/,
+  /排查/,
+  /调试/,
+  /构建/,
+  /搜索/,
+  /查看/,
+];
+
+function normalizeExecutionPath(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  if (text === "router-api") return "router-api";
+  if (text === "shadow") return "shadow";
+  if (text === "loop") return "loop";
+  return DEFAULT_EXECUTION_PATH;
+}
+
+function toPositiveNumber(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+
+function resolveExecutionPath({
+  projectRoot,
+  requestMeta = {},
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const config = loadConfigImpl(projectRoot || process.cwd());
+  return normalizeExecutionPath(
+    requestMeta.agent_execution_path
+      || env.UFOO_AGENT_EXECUTION_PATH
+      || config.agentExecutionPath
+      || config.controllerMode
+      || DEFAULT_EXECUTION_PATH
+  );
+}
+
+function classifyPromptIntent(prompt = "") {
+  const text = String(prompt || "").trim();
+  if (!text) return { kind: "general", reason: "empty_prompt" };
+  const hasRoutingSignal = ROUTING_PATTERNS.some((pattern) => pattern.test(text));
+  if (!hasRoutingSignal) return { kind: "general", reason: "no_routing_signal" };
+  const hasNonRoutingSignal = NON_ROUTING_PATTERNS.some((pattern) => pattern.test(text));
+  if (hasNonRoutingSignal) return { kind: "general", reason: "contains_execution_language" };
+  return { kind: "routing", reason: "routing_signal" };
+}
+
+function shouldUseGateRouter({
+  projectRoot,
+  prompt,
+  requestMeta = {},
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const executionPath = resolveExecutionPath({
+    projectRoot,
+    requestMeta,
+    env,
+    loadConfigImpl,
+  });
+  const intent = classifyPromptIntent(prompt);
+  return {
+    executionPath,
+    intent,
+    enabled: executionPath === "router-api" || executionPath === "loop",
+  };
+}
+
+function resolveGateRouterConfig({
+  projectRoot,
+  requestMeta = {},
+  env = process.env,
+  loadConfigImpl = loadConfig,
+} = {}) {
+  const config = loadConfigImpl(projectRoot || process.cwd());
+  return {
+    provider: String(
+      requestMeta.router_provider
+        || env.UFOO_AGENT_ROUTER_PROVIDER
+        || config.routerProvider
+        || "ucode"
+    ).trim(),
+    model: String(
+      requestMeta.router_model
+        || env.UFOO_AGENT_ROUTER_MODEL
+        || config.routerModel
+        || ""
+    ).trim(),
+    timeoutMs: toPositiveNumber(
+      requestMeta.router_timeout_ms
+        || env.UFOO_AGENT_ROUTER_TIMEOUT_MS
+        || config.routerTimeoutMs,
+      DEFAULT_TIMEOUT_MS
+    ),
+    confidenceThreshold: Math.min(
+      1,
+      toPositiveNumber(
+        requestMeta.router_confidence_threshold
+          || env.UFOO_AGENT_ROUTER_CONFIDENCE_THRESHOLD
+          || config.routerConfidenceThreshold,
+        DEFAULT_CONFIDENCE_THRESHOLD
+      )
+    ),
+  };
+}
+
+function normalizeInjectionMode(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  return text === "queued" ? "queued" : "immediate";
+}
+
+function normalizeGateRouterResult(payload = {}, fallbackMessage = "") {
+  if (!payload || typeof payload !== "object") {
+    return {
+      decision: "upgrade_to_main_router",
+      target: "unknown",
+      confidence: 0,
+      reason: "",
+      message: String(fallbackMessage || ""),
+      injection_mode: "immediate",
+    };
+  }
+
+  const rawConfidence = Number(payload.confidence);
+  const normalizedConfidence = Number.isFinite(rawConfidence)
+    ? Math.max(0, Math.min(1, rawConfidence))
+    : 0;
+  const rawDecision = String(payload.decision || "").trim().toLowerCase();
+  const normalizedDecision = rawDecision === "direct_dispatch"
+    || rawDecision === "upgrade_to_main_router"
+    ? rawDecision
+    : (String(payload.target || "").trim() && String(payload.target || "").trim() !== "unknown"
+        ? "direct_dispatch"
+        : "upgrade_to_main_router");
+
+  return {
+    decision: normalizedDecision,
+    target: String(payload.target || "unknown").trim() || "unknown",
+    confidence: normalizedConfidence,
+    reason: String(payload.reason || "").trim(),
+    message: String(payload.message || fallbackMessage || "").trim(),
+    injection_mode: normalizeInjectionMode(payload.injection_mode),
+  };
+}
+
+module.exports = {
+  classifyPromptIntent,
+  normalizeExecutionPath,
+  normalizeGateRouterResult,
+  resolveExecutionPath,
+  resolveGateRouterConfig,
+  shouldUseGateRouter,
+};

package/src/controller/routerFastPath.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const {
+  classifyPromptIntent,
+  normalizeExecutionPath,
+  normalizeGateRouterResult,
+  resolveExecutionPath,
+  resolveGateRouterConfig,
+  shouldUseGateRouter,
+} = require("./gateRouter");
+
+module.exports = {
+  classifyPromptIntent,
+  normalizeExecutionPath,
+  normalizeRouteAgentResult: normalizeGateRouterResult,
+  resolveExecutionPath,
+  resolveRouterFastPathConfig: resolveGateRouterConfig,
+  shouldUseRouterFastPath: shouldUseGateRouter,
+  normalizeGateRouterResult,
+  resolveGateRouterConfig,
+  shouldUseGateRouter,
+};