|
4 | 4 |
|
5 | 5 | try { |
6 | 6 | plugin("Console") |
7 | | - var args = isDef(global._args) ? global._args : processExpr(" ") |
| 7 | + var args = processExpr(" ") |
| 8 | + |
| 9 | + // Init |
| 10 | + if (!(isString(args.libs) && args.libs.trim().length > 0)) { |
| 11 | + var envLibs = args.OAF_MINI_A_LIBS || getEnv("OAF_MINI_A_LIBS") |
| 12 | + if (isString(envLibs) && envLibs.trim().length > 0) { |
| 13 | + args.libs = envLibs.trim() |
| 14 | + //log("Using libs from OAF_MINI_A_LIBS environment variable.") |
| 15 | + } |
| 16 | + //global._args = args |
| 17 | + } |
| 18 | + |
| 19 | + (function(args) { |
| 20 | + if (args.__modeApplied === true) return |
| 21 | + if (!isString(args.mode)) return |
| 22 | + var modeName = args.mode.trim() |
| 23 | + if (modeName.length === 0) return |
| 24 | + |
| 25 | + var modesPath = getOPackPath("mini-a") + "/mini-a-modes.yaml" |
| 26 | + var presets = {} |
| 27 | + try { |
| 28 | + var loaded = io.readFileYAML(modesPath) |
| 29 | + if (isMap(loaded) && isMap(loaded.modes)) { |
| 30 | + presets = loaded.modes |
| 31 | + } else if (isMap(loaded)) { |
| 32 | + presets = loaded |
| 33 | + } else { |
| 34 | + presets = {} |
| 35 | + } |
| 36 | + } catch(e) { |
| 37 | + var errMsg = (isDef(e) && isString(e.message)) ? e.message : e |
| 38 | + logWarn(`Failed to load mode presets for '${modeName}': ${errMsg}`) |
| 39 | + args.__modeApplied = true |
| 40 | + return |
| 41 | + } |
| 42 | + |
| 43 | + // Load custom modes from user's home directory |
| 44 | + function resolveCanonicalPath(basePath, fileName) { |
| 45 | + return io.fileInfo((basePath || ".") + "/" + fileName).canonicalPath |
| 46 | + } |
| 47 | + var modesHome = isDef(__gHDir) ? __gHDir() : java.lang.System.getProperty("user.home") |
| 48 | + var customModesPath = resolveCanonicalPath(modesHome, ".openaf-mini-a_modes.yaml") |
| 49 | + if (io.fileExists(customModesPath)) { |
| 50 | + try { |
| 51 | + var customLoaded = io.readFileYAML(customModesPath) |
| 52 | + var customPresets = {} |
| 53 | + if (isMap(customLoaded) && isMap(customLoaded.modes)) { |
| 54 | + customPresets = customLoaded.modes |
| 55 | + } else if (isMap(customLoaded)) { |
| 56 | + customPresets = customLoaded |
| 57 | + } |
| 58 | + // Merge custom modes with default modes (custom overrides defaults) |
| 59 | + if (isMap(customPresets) && Object.keys(customPresets).length > 0) { |
| 60 | + presets = merge(presets, customPresets) |
| 61 | + } |
| 62 | + } catch(e) { |
| 63 | + var errMsg = (isDef(e) && isString(e.message)) ? e.message : e |
| 64 | + logWarn(`Failed to load custom mode presets from '${customModesPath}': ${errMsg}`) |
| 65 | + } |
| 66 | + } |
| 67 | + |
| 68 | + if (!isMap(presets) || Object.keys(presets).length === 0) { |
| 69 | + logWarn(`Mode '${modeName}' requested but no presets are defined.`) |
| 70 | + args.__modeApplied = true |
| 71 | + return |
| 72 | + } |
| 73 | + |
| 74 | + var keys = Object.keys(presets) |
| 75 | + var resolvedKey |
| 76 | + for (var i = 0; i < keys.length; i++) { |
| 77 | + var key = keys[i] |
| 78 | + if (key === modeName || key.toLowerCase() === modeName.toLowerCase()) { |
| 79 | + resolvedKey = key |
| 80 | + break |
| 81 | + } |
| 82 | + } |
| 83 | + |
| 84 | + if (isUnDef(resolvedKey)) { |
| 85 | + logWarn(`Mode '${modeName}' not found. Available modes: ${keys.join(", ")}`) |
| 86 | + args.__modeApplied = true |
| 87 | + return |
| 88 | + } |
| 89 | + |
| 90 | + var preset = presets[resolvedKey] |
| 91 | + if (!isMap(preset)) { |
| 92 | + logWarn(`Mode '${resolvedKey}' preset is invalid.`) |
| 93 | + args.__modeApplied = true |
| 94 | + return |
| 95 | + } |
| 96 | + |
| 97 | + var applied = [] |
| 98 | + var paramsSource = preset.params |
| 99 | + var applyParam = function(key, value) { |
| 100 | + if (isString(key) && key.length > 0) { |
| 101 | + args[key] = value |
| 102 | + applied.push(key) |
| 103 | + } |
| 104 | + } |
| 105 | + |
| 106 | + if (isArray(paramsSource)) { |
| 107 | + paramsSource.forEach(function(entry) { |
| 108 | + if (!isMap(entry)) return |
| 109 | + Object.keys(entry).forEach(function(paramKey) { |
| 110 | + applyParam(paramKey, entry[paramKey]) |
| 111 | + }) |
| 112 | + }) |
| 113 | + } else if (isMap(paramsSource)) { |
| 114 | + Object.keys(paramsSource).forEach(function(paramKey) { |
| 115 | + applyParam(paramKey, paramsSource[paramKey]) |
| 116 | + }) |
| 117 | + } else if (isDef(paramsSource)) { |
| 118 | + logWarn(`Mode '${resolvedKey}' has unsupported params definition.`) |
| 119 | + } |
| 120 | + |
| 121 | + var infoMsg = `Mode '${resolvedKey}' enabled` |
| 122 | + if (isString(preset.description) && preset.description.length > 0) { |
| 123 | + infoMsg += `: ${preset.description}` |
| 124 | + } |
| 125 | + log(infoMsg) |
| 126 | + |
| 127 | + if (applied.length > 0) { |
| 128 | + log(`Mode '${resolvedKey}' applied defaults for: ${applied.join(", ")}`) |
| 129 | + } else { |
| 130 | + log(`Mode '${resolvedKey}' did not change any arguments (overrides already provided).`) |
| 131 | + } |
| 132 | + |
| 133 | + args.mode = resolvedKey |
| 134 | + args.__modeApplied = true |
| 135 | + })(args) |
| 136 | + |
| 137 | + // Choose |
| 138 | + if (toBoolean(args.modelman) === true) { |
| 139 | + // Start model management mode |
| 140 | + load("mini-a-modelman.js") |
| 141 | + exit(0) |
| 142 | + } else if (toBoolean(args.web) === true || toBoolean(args.onport) === true) { |
| 143 | + // Start web mode |
| 144 | + oJobRunFile(getOPackPath("mini-a") + "/mini-a-web.yaml", args, genUUID(), __, false) |
| 145 | + exit(0) |
| 146 | + } else if (isDef(args.goal)) { |
| 147 | + // Start cli mode |
| 148 | + oJobRunFile(getOPackPath("mini-a") + "/mini-a.yaml", args, genUUID(), __, false) |
| 149 | + exit(0) |
| 150 | + } |
8 | 151 |
|
9 | 152 | // Helper functions |
10 | 153 | // ---------------- |
|
66 | 209 | var consoleReader = __ |
67 | 210 | var commandHistory = __ |
68 | 211 | var lastConversationStats = __ |
69 | | - var slashCommands = ["help", "set", "toggle", "unset", "show", "reset", "last", "clear", "context", "compact", "summarize", "history", "exit", "quit"] |
| 212 | + var slashCommands = ["help", "set", "toggle", "unset", "show", "reset", "last", "clear", "context", "compact", "summarize", "history", "model", "exit", "quit"] |
70 | 213 | var resumeConversation = parseBoolean(findArgumentValue(args, "resume")) === true |
71 | 214 | var conversationArgValue = findArgumentValue(args, "conversation") |
72 | 215 | var initialConversationPath = isString(conversationArgValue) && conversationArgValue.trim().length > 0 |
@@ -1126,6 +1269,7 @@ try { |
1126 | 1269 | " " + colorifyText("/compact", "BOLD") + colorifyText(" [n] Summarize old context, keep last n messages", hintColor), |
1127 | 1270 | " " + colorifyText("/summarize", "BOLD") + colorifyText(" [n] Compact and display an LLM-generated conversation summary", hintColor), |
1128 | 1271 | " " + colorifyText("/history", "BOLD") + colorifyText(" [n] Show the last n conversation turns", hintColor), |
| 1272 | + " " + colorifyText("/model", "BOLD") + colorifyText(" [target] Choose a different model (target: model or modellc)", hintColor), |
1129 | 1273 | " " + colorifyText("/exit", "BOLD") + colorifyText(" Leave the console", hintColor) |
1130 | 1274 | ] |
1131 | 1275 | print( ow.format.withSideLine( lines.join("\n"), __, promptColor, hintColor, ow.format.withSideLineThemes().openCurvedRect) ) |
@@ -1250,6 +1394,61 @@ try { |
1250 | 1394 | } |
1251 | 1395 | continue |
1252 | 1396 | } |
| 1397 | + if (command === "model" || command.indexOf("model ") === 0) { |
| 1398 | + var target = "model" // default to model |
| 1399 | + if (command.indexOf("model ") === 0) { |
| 1400 | + var targetArg = command.substring(6).trim().toLowerCase() |
| 1401 | + if (targetArg === "modellc" || targetArg === "lc") { |
| 1402 | + target = "modellc" |
| 1403 | + } else if (targetArg === "model") { |
| 1404 | + target = "model" |
| 1405 | + } else { |
| 1406 | + print(colorifyText("Invalid target. Use 'model' or 'modellc'.", errorColor)) |
| 1407 | + continue |
| 1408 | + } |
| 1409 | + } |
| 1410 | + try { |
| 1411 | + // Store original args and set temporary args for model manager |
| 1412 | + var originalGlobalArgs = clone(args) |
| 1413 | + global._args = merge(args, { __noprint: true }) |
| 1414 | + |
| 1415 | + // Set up result capture mechanism |
| 1416 | + global.__mini_a_con_capture_model = true |
| 1417 | + global.__mini_a_con_model_result = __ |
| 1418 | + |
| 1419 | + // Load the model manager (which will execute mainOAFModel and store result) |
| 1420 | + var modelManPath = getOPackPath("mini-a") + "/mini-a-modelman.js" |
| 1421 | + load(modelManPath) |
| 1422 | + |
| 1423 | + // Get the captured result |
| 1424 | + var selectedModel = global.__mini_a_con_model_result |
| 1425 | + |
| 1426 | + // Clean up |
| 1427 | + delete global.__mini_a_con_capture_model |
| 1428 | + delete global.__mini_a_con_model_result |
| 1429 | + args = originalGlobalArgs |
| 1430 | + |
| 1431 | + if (isMap(selectedModel)) { |
| 1432 | + sessionOptions[target] = af.toSLON(selectedModel) |
| 1433 | + |
| 1434 | + /*if (target == "model") args.model = af.toSLON(selectedModel) |
| 1435 | + else if (target == "lowcost") args.modellc = af.toSLON(selectedModel)*/ |
| 1436 | + |
| 1437 | + print(colorifyText("Model definition set for " + target + ".", successColor)) |
| 1438 | + //print(colorifyText("Value: " + modelSLON, hintColor)) |
| 1439 | + } else { |
| 1440 | + print(colorifyText("No model selected.", hintColor)) |
| 1441 | + } |
| 1442 | + } catch (modelError) { |
| 1443 | + printErr(ansiColor("ITALIC," + errorColor, "!!") + colorifyText(" Failed to load model: " + modelError, errorColor)) |
| 1444 | + $err(modelError) |
| 1445 | + // Clean up on error |
| 1446 | + delete global.__mini_a_con_capture_model |
| 1447 | + delete global.__mini_a_con_model_result |
| 1448 | + if (isDef(originalGlobalArgs)) args = originalGlobalArgs |
| 1449 | + } |
| 1450 | + continue |
| 1451 | + } |
1253 | 1452 | if (command.indexOf("toggle ") === 0) { |
1254 | 1453 | toggleOption(command.substring(7).trim()) |
1255 | 1454 | continue |
|
0 commit comments